smagacor 0.0.1 → 0.0.2

data/data/smagacor/tictactoe/game.info

@@ -2,6 +2,6 @@
 name: TicTacToe
 icon: tictactoe.png
 file: tictactoe.rb
-classname: Smagacor::TicTacToe::TicTacToeUI
+classname: Smagacor::TicTacToe::TicTacToeGame
 description: This is the well known game TicTacToe
 category: Board Games

data/data/smagacor/tictactoe/tictactoe.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: tictactoe.rb 190 2005-02-02 19:26:25Z thomas $
+# $Id: tictactoe.rb 362 2005-11-26 17:56:46Z thomas $
 #
 # smagacor - a collection of small games in ruby
 # Copyright (C) 2004 Thomas Leitner
@@ -19,280 +19,369 @@
 #
 #++
 #
-require 'observer'
+require 'smagacor/listener'
 
-module Smagacor
+# TicTacToe for Smagacor
+module Smagacor::TicTacToe
 
-  # TicTacToe for Smagacor
-  module TicTacToe
+  # Base player class
+  class Player
 
-    # Base player class
-    class Player
+    # Return a new player with the +sign+.
+    def initialize
+      @field = -1
+    end
 
-      # Defines whether the player can currently make a move. Default is +false+.
-      attr_accessor :can_move
+    # Defines whether the player has selected a field. Default is +false+.
+    def field_selected?
+      @field != -1
+    end
 
-      # Return a new player.
-      def initialize
-        @can_move = false
-      end
+    # Invoked by the game engine to get the field. The field is reset to the standard value so that
+    # #field_selected? returns false.
+    def selected_field
+      field, @field = @field, -1
+      field
+    end
+
+  end
 
-      # Invoked by the game engine to get the move.
-      def move() end
 
+  # Human player. Provides the interface for a human to play TicTacToe.
+  class HumanPlayer < Player
+
+    # Set the +field+ which is returned by the next #selcted_field.
+    def set_field( field )
+      @field = field
     end
 
+  end
 
-    # Human player. Provides the interface for a human to play TicTacToe.
-    class HumanPlayer < Player
 
-      def initialize
-        super
-        @field = -1
-      end
+  # AI computer player. Not yet implemented!
+  class ComputerPlayer < Player
 
-      # See Player#move
-      def move
-        self.can_move = false
-        @field
-      end
+    def selected_field
+    end
 
-      # Set the +field+ which is returned by the next #move. <tt>can_move</tt> is set to +true+ so
-      # that the game engine knows the this player has chosen a field.
-      def set_field( field )
-        @field = field
-        self.can_move = true
-      end
+  end
+
+
+  # The TicTacToe board.
+  class Board < String
+
+    # Defines the empty field.
+    FIELD_EMPTY = ?-
+
+    def initialize( size )
+      super( FIELD_EMPTY.chr * size )
+    end
 
+    # Redefined each so that the methods from Enumerable work correctly.
+    def each( &block )
+      each_byte( &block )
     end
 
+  end
+
+
+  # Game engine for TicTacToe. Knows how to correctly play TicTacToe.
+  class TicTacToe
+
+    PLAYER1 = ?1
+    PLAYER2 = ?2
+
+    include Listener
 
-    # AI computer player. Not yet implemented!
-    class ComputerPlayer < Player
+    # The board on which is played.
+    attr_accessor :board
 
-      def move
+    # The current player.
+    attr_reader :cur_player
+
+    # Create a new TicTacToe game with the given +players+.
+    def initialize( player1, player2 )
+      @player1 = player1
+      @player2 = player2
+      @board = Board.new( 9 )
+      add_msg_name( :move )
+      add_msg_name( :finished )
+    end
+
+    # Initialize the game state.
+    def init
+      @board = Board.new( 9 )
+      @cur_player = @player1
+    end
+
+    # Play one (or more) round(s) of a TicTacToe game. When the current player has made his move
+    # (Player#field_selected?), his move is verified and the board changed. Then it is the turn of the
+    # other player. As long as the current player can make a move (and the game is not finished),
+    # the method runs. When the current player cannot make a move, the method exists and it has to
+    # be called again, when the current player can make his move.
+    def play_round
+      while @cur_player.field_selected? && !game_finished?
+        logger.info { "Current board: #{@board}" }
+        logger.info { "Current player: #{sign(@cur_player).chr}" }
+        field = @cur_player.selected_field
+        logger.info { "Field selected: #{field}" }
+        if @board[field] == Board::FIELD_EMPTY
+          @board[field] = sign( @cur_player )
+          switch_players
+          dispatch_msg( :move, field, @board[field] )
+        end
       end
+      if game_finished?
+        logger.info { "Game finished" }
+        dispatch_msg( :finished, player_won )
+      end
+    end
+
+    #######
+    private
+    #######
 
+    def sign( player )
+      ( player == @player1 ? PLAYER1 : PLAYER2 )
     end
 
+    def switch_players
+      @cur_player = ( @cur_player == @player1 ? @player2 : @player1 )
+    end
 
-    # The TicTacToe board.
-    class Board < String
+    # True if the board is full.
+    def board_full?
+      @board.all? {|i| i != Board::FIELD_EMPTY}
+    end
 
-      # Defines the empty field.
-      FIELD_EMPTY = ?-
+    # True if the game is over
+    def game_finished?
+      board_full? || player_won?( PLAYER1 ) || player_won?( PLAYER2 )
+    end
 
-      def initialize( size )
-        super( FIELD_EMPTY.chr * size )
-      end
+    # Return the number of the player who has won.
+    #
+    # Returns
+    # 0:: player 1
+    # 1:: player 2
+    # 2:: draw
+    # -1:: game not finished yet
+    def player_won
+      ( player_won?( PLAYER1 ) ? 0 : ( player_won?( PLAYER2 ) ? 1 : ( board_full? ? 2 : -1 ) ) )
+    end
 
-      # Redefined each so that the methods from Enumerable work correctly.
-      def each( &block )
-        each_byte( &block )
-      end
+    # Win situations.
+    WIN_SITUATIONS = [[0,1,2], [3,4,5], [6,7,8], [0,3,6],
+      [1,4,7], [2,5,8], [0,4,8], [2,4,6]]
 
+    # Check if +player+ has won the game.
+    def player_won?( player )
+      WIN_SITUATIONS.each {|a,b,c| return true if @board[a] == player && @board[b] == player && @board[c] == player }
+      return false
     end
 
+  end
 
-    # Game engine for TicTacToe. Knows how to correctly play TicTacToe.
-    class TicTacToe
 
-      include Observable
+  class TicTacToeCanvas < Qt::Widget
 
-      # The board on which is played.
-      attr_accessor :board
+    signals 'clicked(int)'
 
-      # Create a new TicTacToe game with the given +players+.
-      def initialize( players )
-        @players = players
-        @board = Board.new( 9 )
-      end
+    def initialize( *args )
+      super( *args )
+      setBackgroundMode( Qt::NoBackground )
+      @x = @sx = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'x.png' ) )
+      @o = @so = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'o.png' ) )
+    end
 
-      # Return the current player if the game has been initialized.
-      def cur_player
-        @players[@cur_player] if @cur_player < 2
-      end
+    def game=( game )
+      @game = game
+      @game.add_msg_listener( :move, method(:onMove) )
+    end
 
-      # Initialize the game state.
-      def init
-        @board = Board.new( 9 )
-        @cur_player = 0
+    def onMove( field, player )
+      painter = Qt::Painter.new( self )
+      case player
+      when TicTacToe::PLAYER1 then paintX( painter, field )
+      when TicTacToe::PLAYER2 then paintO( painter, field )
       end
+    end
+
+    def paintPlayArea( painter )
+      painter.setPen( Qt::Pen.new( Qt::black, @b_padding/10, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin ) )
+      painter.drawLine( @b_padding + @b_width/3, @b_padding, @b_padding + @b_width/3, @b_padding + @b_width )
+      painter.drawLine( @b_padding + @b_width*2/3, @b_padding, @b_padding + @b_width*2/3, @b_padding + @b_width )
+      painter.drawLine( @b_padding, @b_padding + @b_width/3, @b_padding + @b_width, @b_padding + @b_width/3 )
+      painter.drawLine( @b_padding, @b_padding + @b_width*2/3, @b_padding + @b_width, @b_padding + @b_width*2/3 )
+    end
 
-      # Play one (or more) round(s) of a TicTacToe game. When the current player can make a move
-      # (Player#can_move), his move is verified and the board changed. Then it is the turn of the
-      # other player. As long as the current player can make a move (and the game is not finished),
-      # the method runs. When the current player cannot make a move, the method exists and it has to
-      # be called again, when the current player can make his move.
-      def play_round
-        while @players[@cur_player].can_move && !game_finished?
-          logger.info { "Current board: #{@board}" }
-          logger.info { "Current player: #{cur_player}" }
-          field = @players[@cur_player].move
-          logger.info { "Field selected: #{field}" }
-          if @board[field] == Board::FIELD_EMPTY
-            @board[field] = @cur_player.to_s
-            @cur_player = 1 - @cur_player
-            changed
-            notify_observers( :move )
+    def paintCurGame( painter )
+      unless @game.nil?
+        @game.board.each_with_index do |item, index|
+          case item
+          when TicTacToe::PLAYER1 then paintX( painter, index )
+          when TicTacToe::PLAYER2 then paintO( painter, index )
           end
         end
-        if game_finished?
-          logger.info { " Game finished" }
-          changed
-          notify_observers( :finished, player_won )
-        end
       end
+    end
 
-      private
+    def paintX( painter, field )
+      x, y, w = field_info( field )
+      @sx = @x.smoothScale( w, w ) if @sx.width != w
+      painter.drawImage( x, y, @sx )
+    end
 
-      # True if the board is full.
-      def board_full?
-        @board.all? {|i| i != Board::FIELD_EMPTY}
-      end
+    def paintO( painter, field )
+      x, y, w = field_info( field )
+      @so = @o.smoothScale( w, w ) if @so.width != w
+      painter.drawImage( x, y, @so )
+    end
 
-      # Win situations.
-      WIN_SITUATIONS = [[0,1,2], [3,4,5], [6,7,8], [0,3,6],
-                        [1,4,7], [2,5,8], [0,4,8], [2,4,6]]
+    def paintEvent( event )
+      pix = Qt::Pixmap.new( width, height )
+      painter = Qt::Painter.new
+      painter.begin( pix )
+      painter.setBrush( Qt::white )
+      painter.drawRect( 0, 0, self.width, self.height )
+      paintPlayArea( painter )
+      paintCurGame( painter )
+      painter.end
+
+      p = Qt::Painter.new( self )
+      p.drawPixmap( 0, 0, pix )
+    end
 
-      # True if the game is over
-      def game_finished?
-        board_full? || player_won?( ?0 ) || player_won?( ?1 )
-      end
+    def resizeEvent( event )
+      width = (self.width > self.height ? self.height : self.width )
+      @b_width = (width * 0.8).to_i
+      @b_padding = (width * 0.1).to_i
+      @f_width = @b_width/5
+      @f_padding = @b_padding + (@b_width/3 - @f_width)/2
+    end
 
-      # Return the number of the player who has won.
-      #
-      # Returns
-      # 0:: player 1
-      # 1:: player 2
-      # 2:: draw
-      # -1:: game not finished yet
-      def player_won
-        ( player_won?( ?0 ) ? 0 : ( player_won?( ?1 ) ? 1 : ( board_full? ? 2 : -1 ) ) )
-      end
+    def field_info( field )
+      [@f_padding + @b_width/3 * (field % 3), @f_padding + @b_width/3 * (field / 3), @f_width]
+    end
 
-      # Check if +player+ has won the game.
-      def player_won?( player )
-        WIN_SITUATIONS.each {|a,b,c| return true if @board[a] == player && @board[b] == player && @board[c] == player }
-        return false
+    def mouseReleaseEvent( event )
+      pos = Proc.new do |point|
+        case point
+        when 0..(@b_padding + @b_width/3): 0
+        when (@b_padding + @b_width/3)..(@b_padding + @b_width*2/3): 1
+        else 2
+        end
       end
-
+      emit clicked( pos[event.x] + pos[event.y]*3  )
     end
 
+  end
 
-    # Widget for TicTacToe.
-    class TicTacToeUI < FXHorizontalFrame
 
-      attr_reader :gameinfo
+  # Widget for TicTacToe.
+  class TicTacToeUI < Qt::Widget
 
-      def initialize( p, gameinfo )
-        super( p )
-        @gameinfo = gameinfo
+    slots 'start_game()', 'clicked(int)'
 
-        @canvas = FXCanvas.new( self, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y )
-        @canvas.connect( SEL_PAINT, method( :onPaint ) )
-        @canvas.connect( SEL_LEFTBUTTONRELEASE, method( :onCanvasClick ) )
-        FXVerticalSeparator.new( self )
-        options = FXVerticalFrame.new( self, LAYOUT_FILL_Y )
+    attr_reader :gameinfo
 
-        p = Proc.new do |name|
-          FXLabel.new( options, name )
-          box = FXComboBox.new( options, 20, 2, nil, 0, COMBOBOX_NORMAL|COMBOBOX_STATIC|FRAME_SUNKEN )
-          box.appendItem( 'Human', HumanPlayer )
-          box.appendItem( 'Computer', ComputerPlayer )
-          box
-        end
-        @player1 = p.call( 'Player 1' )
-        @player2 = p.call( 'Player 2' )
+    PLAYERS = {'Human' => HumanPlayer, 'Computer' => ComputerPlayer}
 
-        FXButton.new( options, "Start Game", nil, nil, 0, LAYOUT_FILL_X|BUTTON_NORMAL ).connect( SEL_COMMAND, method( :onStartGame ) )
+    def initialize( p, gameinfo )
+      super( p )
+      @gameinfo = gameinfo
 
-        @xicon = File.join( gameinfo.directory, 'x.png' )
-        @oicon = File.join( gameinfo.directory, 'o.png' )
-      end
+      @canvas = TicTacToeCanvas.new( self )
+      connect( @canvas, SIGNAL('clicked(int)'), self, SLOT('clicked(int)') )
 
-      def create
-        super
+      optionsLayout = Qt::VBoxLayout.new
+      optionsLayout.setSpacing( 3 )
+      optionsLayout.setMargin( 6 )
+      p = Proc.new do |name|
+        optionsLayout.addWidget( Qt::Label.new( name, self ) )
+        box = Qt::ComboBox.new( false, self )
+        optionsLayout.addWidget( box )
+        box.insertItem( 'Human' )
+        box.insertItem( 'Computer' )
+        box
       end
+      @player1 = p.call( 'Player 1' )
+      @player2 = p.call( 'Player 2' )
 
-      def onCanvasClick( sender, sel, event )
-        if !@game.nil? && @game.cur_player.respond_to?( :set_field )
-          width, padding = get_lengths
-          pos = Proc.new do |point|
-            case point
-            when 0..(padding + width/3): 0
-            when (padding + width/3)..(padding + width*2/3): 1
-            else 2
-            end
-          end
-          @game.cur_player.set_field( pos[event.click_x] + pos[event.click_y]*3 )
-          @game.play_round
-        end
-      end
+      button = Qt::PushButton.new( "Start Game", self )
+      connect( button, SIGNAL('clicked()'), self, SLOT('start_game()') )
 
-      def onStartGame( sender, sel, event )
-        p = [@player1.getItemData( @player1.currentItem ).new, @player2.getItemData( @player2.currentItem ).new ]
-        @canvas.update
-        @game = TicTacToe.new( p)
-        @game.add_observer( self )
-        @game.init
+      optionsLayout.addSpacing( 10 )
+      optionsLayout.addWidget( button )
+      optionsLayout.addStretch
+
+      @xicon = File.join( gameinfo.directory, 'x.png' )
+      @oicon = File.join( gameinfo.directory, 'o.png' )
+
+      layout = Qt::HBoxLayout.new( self )
+      layout.addWidget( @canvas, 1 )
+      layout.addLayout( optionsLayout )
+    end
+
+    def clicked( field )
+      if !@game.nil? && @game.cur_player.respond_to?( :set_field )
+        @game.cur_player.set_field( field )
         @game.play_round
       end
+    end
 
-      def update( reason, winner=nil )
-        case reason
-        when :move: @canvas.update
-        when :finished
-          msg = (winner < 2 ? "Player #{winner+1}" : "Nobody" ) + " has won!"
-          FXMessageBox.information( self, MBOX_OK, "Result", msg )
-        end
-      end
+    def start_game
+      @game = TicTacToe.new( PLAYERS[@player1.currentText].new, PLAYERS[@player2.currentText].new )
+      @canvas.game = @game
+      @game.add_msg_listener( :move, method(:onMove) )
+      @game.add_msg_listener( :finished, method(:finished) )
+      @game.init
+      @game.play_round
+      @canvas.update
+    end
 
-      def onPaint( sender, sel, event )
-        FXDCWindow.new( sender, event ) do |dc|
-          dc.foreground = FXColor::White
-          dc.fillRectangle( 0, 0, sender.width, sender.height )
-          paintPlayArea( dc )
-          paintCurGame( dc )
-        end
-      end
+    def onMove( field, player )
+      @manager.add_undo_info( [field, player] ) # TODO think about AI moves, player changes etc
+    end
 
-      private
+    def finished( winner )
+      msg = (winner < 2 ? "Player #{winner+1}" : "Nobody" ) + " has won!"
+      Qt::MessageBox.information( self, "Result", msg, Qt::MessageBox::Ok )
+    end
 
-      def get_lengths
-        width = (@canvas.width > @canvas.height ? @canvas.height : @canvas.width )
-        [(width * 0.8).to_i, (width * 0.1).to_i]
-      end
+    def set_undo_manager( manager )
+      @manager = manager
+      manager.add_msg_listener( :undo, method(:undo) )
+      manager.add_msg_listener( :redo, method(:redo) )
+    end
 
-      def paintPlayArea( dc )
-        width, padding = get_lengths
-        dc.foreground = FXColor::Black
-        dc.lineWidth = 10
-        dc.lineCap = CAP_ROUND
-        dc.drawLine( padding + width/3, padding, padding + width/3, padding + width )
-        dc.drawLine( padding + width*2/3, padding, padding + width*2/3, padding + width )
-        dc.drawLine( padding, padding + width/3, padding + width, padding + width/3 )
-        dc.drawLine( padding, padding + width*2/3, padding + width, padding + width*2/3 )
-      end
+    def undo( info )
+      #TODO also undo cur player
+      @game.board[info[0]] = Board::FIELD_EMPTY
+      @canvas.update
+    end
 
-      def paintCurGame( dc )
-        unless @game.nil?
-          width, padding = get_lengths
-          size = width/5
-          padding = padding + (width/3 - size)/2
-          @game.board.each_with_index do |item, index|
-            case item
-            when ?0
-              dc.foreground = FXColor::Red
-              dc.drawRectangle( padding + width/3 * (index % 3), padding + width/3 * (index / 3), size, size )
-            when ?1
-              dc.foreground = FXColor::Green
-              dc.drawCircle( padding + size/2 + width/3 * (index % 3), padding + size/2 + width/3 * (index / 3), size/2 )
-            end
-          end
-        end
-      end
+    def redo( info )
+      @game.board[info[0]] = info[1]
+      @canvas.update
+    end
+
+  end
+
+
+  class TicTacToeGame < Smagacor::GamePlugin
+
+    def initialize( p, gameinfo )
+      @parent = p
+      @widget = TicTacToeUI.new( p, gameinfo )
+    end
+
+    def game_widget
+      @widget
+    end
 
+    def set_undo_manager( manager )
+      @widget.set_undo_manager( manager )
     end
 
   end