smagacor 0.0.1

data/Rakefile

@@ -0,0 +1,255 @@
+# -*- ruby -*-
+#
+# $Id$
+#
+# smagacor - a collection of small games in ruby
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+
+begin
+  require 'rubygems'
+  require 'rake/gempackagetask'
+rescue Exception
+  nil
+end
+
+require 'rake/clean'
+require 'rake/packagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+# General actions  ##############################################################
+
+$:.push "lib"
+require 'smagacor/controller'
+
+PKG_NAME = "smagacor"
+PKG_VERSION = Smagacor::VERSION.join( '.' )
+PKG_FULLNAME = PKG_NAME + "-" + PKG_VERSION
+PKG_SUMMARY = "A collection of small games in ruby"
+PKG_DESCRIPTION = "Smagacor is a collection of some small games,
+like TicTacToe and Pong. Adding new games should not be to hard,
+as Smagacor provides some useful classes for games."
+
+
+SRC_RB = FileList['lib/**/*.rb', 'bin/**/*', 'data/**/*.rb']
+
+
+# The default task is run if rake is given no explicit arguments.
+
+desc "Default Task"
+task :default => :version
+
+
+# End user tasks ################################################################
+
+desc "Prepares for installation"
+task :prepare do
+  ruby "setup.rb config"
+  ruby "setup.rb setup"
+end
+
+
+desc "Installs the package #{PKG_NAME}"
+task :install => [:prepare] do
+  ruby "setup.rb install"
+end
+
+
+task :clean do
+  ruby "setup.rb clean"
+end
+
+
+CLOBBER << "doc/output" << FileList['texput.*'].to_a
+desc "Builds the documentation (needs webgen installed)"
+task :doc => [:rdoc, :gen_version] do
+  chdir "doc" do
+    sh "webgen -V 3"
+  end
+end
+
+rd = Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/output/rdoc'
+  rdoc.title    = PKG_NAME
+  rdoc.options << '--line-numbers' << '--inline-source' << '-m README'
+  rdoc.rdoc_files.include( 'README' )
+  rdoc.rdoc_files.include( SRC_RB )
+end
+
+task 'test' do |t|
+  ruby "-Ilib -Itest test/runtests.rb"
+end
+
+# Developer tasks ##############################################################
+
+PKG_FILES = FileList.new( [
+                            'setup.rb',
+                            'install.rb',
+                            'TODO',
+                            'COPYING',
+                            'README',
+                            'Rakefile',
+                            'ChangeLog',
+                            'VERSION',
+                            'bin/**/*',
+                            'lib/**/*',
+                            'doc/**/*',
+                            'test/**/*',
+                            'data/**/*'
+                          ]) do |fl|
+  fl.exclude( /\bsvn\b/ )
+  fl.exclude( 'doc/output' )
+end
+
+task :package => [:gen_files] do
+  chdir 'pkg' do
+    sh "rpaadmin packport #{PKG_NAME}-#{PKG_VERSION}"
+  end
+end
+
+task :gen_changelog do
+  sh "svn log -r HEAD:1 -v > ChangeLog"
+end
+
+task :gen_version do
+  puts "Generating VERSION file"
+  File.open( 'VERSION', 'w+' ) do |file| file.write( PKG_VERSION + "\n" ) end
+end
+
+task :gen_installrb do
+  puts "Generating install.rb file"
+  File.open( 'install.rb', 'w+' ) do |file|
+    file.write "
+require 'rpa/install'
+
+class Install_#{PKG_NAME} < RPA::Install::FullInstaller
+  name '#{PKG_NAME}'
+  version '#{PKG_VERSION}-1'
+  classification Application
+  build do
+    installdocs %w[COPYING ChangeLog TODO]
+    installdocs 'docs'
+    installrdoc %w[README] + Dir['lib/**/*.rb']
+    installdata
+  end
+  description <<-EOF
+#{PKG_SUMMARY}
+
+#{PKG_DESCRIPTION}
+  EOF
+end
+"
+    end
+end
+
+task :gen_files => [:gen_changelog, :gen_version, :gen_installrb]
+CLOBBER << "ChangeLog" << "VERSION" << "install.rb"
+
+Rake::PackageTask.new( PKG_NAME, PKG_VERSION ) do |p|
+  p.need_tar = true
+  p.need_zip = true
+  p.package_files = PKG_FILES
+end
+
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+
+    #### Basic information
+
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary = PKG_SUMMARY
+    s.description = PKG_DESCRIPTION
+
+    #### Dependencies, requirements and files
+
+    s.files = PKG_FILES.to_a
+
+    s.autorequire = nil
+    s.executables = [ 'smagacor']
+    s.default_executable = 'smagacor'
+
+    #### Documentation
+
+    s.has_rdoc = true
+    s.extra_rdoc_files = rd.rdoc_files.reject do |fn| fn =~ /\.rb$/ end.to_a
+    s.rdoc_options = ['--line-numbers', '-m README']
+
+    #### Author and project details
+
+    s.author = "Thomas Leitner"
+    s.email = "t_leitner@gmx.at"
+    s.homepage = "smagacor.rubyforge.org"
+    s.rubyforge_project = "smagacor"
+  end
+
+  Rake::GemPackageTask.new( spec ) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+  end
+end
+
+=begin
+desc "Creates a tag in the repository"
+task :tag do
+  repositoryPath = File.dirname( $1 ) if `svn info` =~ /^URL: (.*)$/
+  fail "Tag already created in repository " if /#{PKG_FULLNAME}/ =~ `svn ls #{repositoryPath}/versions`
+  sh "svn cp -m 'Created version #{PKG_FULLNAME}' #{repositoryPath}/trunk/#{PKG_NAME} #{repositoryPath}/versions/#{PKG_FULLNAME}"
+end
+=end
+
+desc "Upload documentation to homepage"
+task :uploaddoc => [:doc] do
+  Dir.chdir('doc/output')
+  sh "scp -r * gettalong@rubyforge.org:/var/www/gforge-projects/#{PKG_NAME}/"
+end
+
+
+# Misc tasks ###################################################################
+
+
+def count_lines( filename )
+  lines = 0
+  codelines = 0
+  open( filename ) do |f|
+    f.each do |line|
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+  end
+  [lines, codelines]
+end
+
+
+def show_line( msg, lines, loc )
+  printf "%6s %6s   %s\n", lines.to_s, loc.to_s, msg
+end
+
+desc "Show statistics"
+task :statistics do
+  total_lines = 0
+  total_code = 0
+  show_line( "File Name", "Lines", "LOC" )
+  SRC_RB.each do |fn|
+    lines, codelines = count_lines fn
+    show_line( fn, lines, codelines )
+    total_lines += lines
+    total_code  += codelines
+  end
+  show_line( "Total", total_lines, total_code )
+end

data/TODO

@@ -0,0 +1,19 @@
+---- CURRENT ----
+
+* help -> help for current game
+* make splitter not moveable
+* make splitter hideable
+* implement Pong
+* implement UNDO mechanism
+* implement State saver
+* TicTacToe AI opponent (on base of mini-max, nega-max,...)
+* complete tests
+
+---- FUTURE ----
+
+* implement Sokoban
+
+---- DONE ----
+
+* BUG: log window should stay behind main window
+* BUG: rake install broken on windows

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/smagacor

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+#
+#
+# $Id$
+#
+# smagacor - a collection of small games in ruby
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+require 'smagacor/smagacor-ui'
+
+Smagacor::SmagacorUI.new.start

data/data/smagacor/tictactoe/game.info

@@ -0,0 +1,7 @@
+--- !thomasleitner,2004/gameinfo
+name: TicTacToe
+icon: tictactoe.png
+file: tictactoe.rb
+classname: Smagacor::TicTacToe::TicTacToeUI
+description: This is the well known game TicTacToe
+category: Board Games

data/data/smagacor/tictactoe/tictactoe.rb

@@ -0,0 +1,300 @@
+#
+#--
+#
+# $Id: tictactoe.rb 190 2005-02-02 19:26:25Z thomas $
+#
+# smagacor - a collection of small games in ruby
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+require 'observer'
+
+module Smagacor
+
+  # TicTacToe for Smagacor
+  module TicTacToe
+
+    # Base player class
+    class Player
+
+      # Defines whether the player can currently make a move. Default is +false+.
+      attr_accessor :can_move
+
+      # Return a new player.
+      def initialize
+        @can_move = false
+      end
+
+      # Invoked by the game engine to get the move.
+      def move() end
+
+    end
+
+
+    # Human player. Provides the interface for a human to play TicTacToe.
+    class HumanPlayer < Player
+
+      def initialize
+        super
+        @field = -1
+      end
+
+      # See Player#move
+      def move
+        self.can_move = false
+        @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
+
+
+    # AI computer player. Not yet implemented!
+    class ComputerPlayer < Player
+
+      def move
+      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
+
+      include Observable
+
+      # The board on which is played.
+      attr_accessor :board
+
+      # Create a new TicTacToe game with the given +players+.
+      def initialize( players )
+        @players = players
+        @board = Board.new( 9 )
+      end
+
+      # Return the current player if the game has been initialized.
+      def cur_player
+        @players[@cur_player] if @cur_player < 2
+      end
+
+      # Initialize the game state.
+      def init
+        @board = Board.new( 9 )
+        @cur_player = 0
+      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 )
+          end
+        end
+        if game_finished?
+          logger.info { " Game finished" }
+          changed
+          notify_observers( :finished, player_won )
+        end
+      end
+
+      private
+
+      # True if the board is full.
+      def board_full?
+        @board.all? {|i| i != Board::FIELD_EMPTY}
+      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]]
+
+      # True if the game is over
+      def game_finished?
+        board_full? || player_won?( ?0 ) || player_won?( ?1 )
+      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
+
+      # 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
+
+
+    # Widget for TicTacToe.
+    class TicTacToeUI < FXHorizontalFrame
+
+      attr_reader :gameinfo
+
+      def initialize( p, gameinfo )
+        super( p )
+        @gameinfo = gameinfo
+
+        @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 )
+
+        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' )
+
+        FXButton.new( options, "Start Game", nil, nil, 0, LAYOUT_FILL_X|BUTTON_NORMAL ).connect( SEL_COMMAND, method( :onStartGame ) )
+
+        @xicon = File.join( gameinfo.directory, 'x.png' )
+        @oicon = File.join( gameinfo.directory, 'o.png' )
+      end
+
+      def create
+        super
+      end
+
+      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
+
+      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
+        @game.play_round
+      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 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
+
+      private
+
+      def get_lengths
+        width = (@canvas.width > @canvas.height ? @canvas.height : @canvas.width )
+        [(width * 0.8).to_i, (width * 0.1).to_i]
+      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 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
+
+    end
+
+  end
+
+end

data/install.rb

@@ -0,0 +1,21 @@
+
+require 'rpa/install'
+
+class Install_smagacor < RPA::Install::FullInstaller
+  name 'smagacor'
+  version '0.0.1-1'
+  classification Application
+  build do
+    installdocs %w[COPYING ChangeLog TODO]
+    installdocs 'docs'
+    installrdoc %w[README] + Dir['lib/**/*.rb']
+    installdata
+  end
+  description <<-EOF
+A collection of small games in ruby
+
+Smagacor is a collection of some small games,
+like TicTacToe and Pong. Adding new games should not be to hard,
+as Smagacor provides some useful classes for games.
+  EOF
+end