smagacor 0.0.1 → 0.0.2

data/data/smagacor/sokoban/sokobanui.rb

@@ -0,0 +1,597 @@
+#
+#--
+#
+# $Id: sokobanui.rb 363 2005-11-26 18:16:30Z 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 'fileutils'
+require 'smagacor/listener'
+
+module Smagacor::Sokoban
+
+  Position = Struct.new( :x, :y )
+  CellChange = Struct.new( :pos, :old_obj, :new_obj )
+  LevelChange = Struct.new( :old_cell, :new_cell )
+
+  class Map
+
+    Man     = ?@
+    Crate   = ?$
+    Wall    = ?#
+    Storage = ?.
+    Floor   = ?\s
+    Empty   = ?-
+    ManOnStorage   = ?+
+    CrateOnStorage = ?*
+
+    include Enumerable
+
+    attr_reader :width
+    attr_reader :height
+    attr_reader :name
+
+    def initialize( str_map, name = '' )
+      @name = name
+      create_map( str_map )
+    end
+
+    def set_pos( pos, item )
+      @map[pos.y][pos.x] = item
+    end
+
+    def get_pos( pos )
+      @map[pos.y][pos.x]
+    end
+
+    def each
+      @map.each {|row| row.each {|field| yield field } }
+    end
+
+    def each_row
+      @map.each {|row| yield row}
+    end
+
+    def each_with_pos
+      @map.each_with_index do |row, y|
+        row.each_with_index do |cell, x|
+          yield cell, Position.new( x, y )
+        end
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def create_map( str_map )
+      @map = str_map.split( /\n/ ).collect { |row| row.unpack( 'C*' ) }
+      @width = @map.max {|a,b| a.length <=> b.length}.length
+      @height = @map.length
+
+      # remove false floor tiles
+      @map.each {|row| row.each_with_index {|c,i| break if c == Wall; row[i] = Empty } }
+      rows = (0..(@height - 1)).to_a
+      (0..(@width - 1)).each do |col|
+        rows.each { |row| break if  @map[row][col] == Wall; next if @map[row][col].nil?; @map[row][col] = Empty }
+        rows.reverse.each { |row| break if @map[row][col] == Wall; next if @map[row][col].nil?; @map[row][col] = Empty }
+      end
+    end
+
+  end
+
+
+  class Level
+
+    include Listener
+
+    attr_reader :map
+    attr_reader :man_pos
+
+    def initialize( map, name = '' )
+      @original_map = Map.new( map, name )
+      reset
+      add_msg_name( :level_changed )
+      add_msg_name( :move_impossible )
+      add_msg_name( :level_finished )
+    end
+
+    def move( direction )
+      move_possible = true
+
+      newpos = Level.new_pos( @man_pos, direction )
+      case @map.get_pos( newpos )
+      when Map::Floor, Map::Storage
+        lc = move_man( newpos )
+        dispatch_msg( :level_changed, [lc] )
+
+      when Map::Wall
+        dispatch_msg( :move_impossible )
+        move_possible = false
+
+      when Map::Crate, Map::CrateOnStorage
+        crate_new_pos = Level.new_pos( newpos, direction )
+        case @map.get_pos( crate_new_pos )
+        when Map::Wall, Map::Crate, Map::CrateOnStorage
+          dispatch_msg( :move_impossible )
+          move_possible = false
+        else
+          lc_crate = move_crate( newpos, crate_new_pos )
+          lc_man = move_man( newpos )
+          dispatch_msg( :level_changed, [lc_man, lc_crate] )
+        end
+      end
+      dispatch_msg( :level_finished ) if level_finished?
+      return move_possible
+    end
+
+    def move_man( newpos )
+      n = CellChange.new( newpos, @map.get_pos( newpos ) )
+      o = CellChange.new( @man_pos, @map.get_pos( @man_pos ) )
+      case @map.get_pos( newpos )
+      when Map::Floor then @map.set_pos( newpos, Map::Man )
+      when Map::Storage then @map.set_pos( newpos, Map::ManOnStorage )
+      end
+      case @map.get_pos( @man_pos )
+      when Map::Man then @map.set_pos( @man_pos, Map::Floor )
+      when Map::ManOnStorage then @map.set_pos( @man_pos, Map::Storage )
+      end
+      n.new_obj = @map.get_pos( newpos )
+      o.new_obj = @map.get_pos( @man_pos )
+
+      @man_pos = newpos
+      LevelChange.new( o, n )
+    end
+
+    def move_crate( oldpos, newpos )
+      n = CellChange.new( newpos, @map.get_pos( newpos ) )
+      o = CellChange.new( oldpos, @map.get_pos( oldpos ) )
+      case @map.get_pos( newpos )
+      when Map::Floor then @map.set_pos( newpos, Map::Crate )
+      when Map::Storage then @map.set_pos( newpos, Map::CrateOnStorage )
+      end
+      case @map.get_pos( oldpos )
+      when Map::Crate then @map.set_pos( oldpos, Map::Floor )
+      when Map::CrateOnStorage then @map.set_pos( oldpos, Map::Storage )
+      end
+      n.new_obj = @map.get_pos( newpos )
+      o.new_obj = @map.get_pos( oldpos )
+      LevelChange.new( o, n )
+    end
+
+    def level_finished?
+      !( @map.any? {|item| item == Map::Storage || item == Map::ManOnStorage } )
+    end
+
+    def reset
+      @map = Marshal.load( Marshal.dump( @original_map ) )
+      recalc_man_pos
+    end
+
+    def recalc_man_pos
+      @man_pos = Level.find_man( @map )
+    end
+
+    def Level.find_man( map )
+      map.each_with_pos {|cell, pos| return pos if cell == Map::Man || cell == Map::ManOnStorage }
+    end
+
+
+    def Level.new_pos( pos, direction )
+      case direction
+      when :left then Position.new( pos.x - 1, pos.y )
+      when :right then Position.new( pos.x + 1, pos.y )
+      when :up then Position.new( pos.x, pos.y - 1 )
+      when :down then Position.new( pos.x, pos.y + 1)
+      end
+    end
+
+  end
+
+
+  class LevelCollection < Array
+
+    attr_reader :name
+
+    def initialize( data, name )
+      super()
+      @name = name
+      leveldata = data.split( /\n;.*\n('.*?'\n)?\n/ )
+      i = 0
+      while i < leveldata.length
+        if !leveldata[i].empty?
+          name = if leveldata[i][0] == ?'
+                   i += 1
+                   leveldata[i-1][1..-3]
+                 else
+                   ''
+                 end
+          self << Level.new( leveldata[i], name )
+        end
+        i += 1
+      end
+    end
+
+  end
+
+
+  class Sokoban
+
+    include Listener
+    include Enumerable
+
+    attr_reader :collections
+
+    def initialize
+      add_msg_name( :level_selected )
+      @collection_index = -1
+      @level_index = -1
+      @collections = []
+    end
+
+    def load_level_collection( data, name )
+      @collections << LevelCollection.new( data, name )
+    end
+
+    def cur_level
+      @collections[@collection_index][@level_index] if @collection_index >= 0
+    end
+
+    def each
+      @collections.each {|c| c.each {|l| yield( c, l ) } }
+    end
+
+    def each_with_index
+      @collections.each_with_index {|c, ci| c.each_with_index {|l, li| yield( c, ci, l, li ) } }
+    end
+
+    def select_collection( index )
+      init_level( 0, index )
+    end
+
+    def next_collection
+      init_level( 0, @collection_index + 1 )
+    end
+
+    def prev_collection
+      init_level( 0, @collection_index - 1 )
+    end
+
+    def select_level( index, colindex = @collection_index )
+      init_level( index, colindex )
+    end
+
+    def next_level
+      init_level( @level_index + 1 )
+    end
+
+    def prev_level
+      init_level( @level_index - 1 )
+    end
+
+    #######
+    private
+    #######
+
+    def init_level( levelindex, colindex = @collection_index )
+      oldcolindex = @collection_index
+      oldlevelindex = @level_index
+      @collection_index = colindex % @collections.length
+      @level_index = levelindex % @collections[@collection_index].length
+      cur_level.reset
+      dispatch_msg( :level_selected, (oldcolindex == -1 ? nil : @collections[oldcolindex][oldlevelindex]), cur_level )
+    end
+
+  end
+
+
+  class SokobanCanvas < Qt::Widget
+
+    def initialize( parent, sokoban )
+      super( parent )
+      @sokoban = sokoban
+      @sokoban.add_msg_listener( :level_selected, method(:on_level_selected) )
+      setBackgroundMode( Qt::NoBackground )
+      setFocusPolicy( Qt::Widget::StrongFocus )
+      setFocus
+
+      @wall = @swall = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'wall.png' ) )
+      @man = @sman = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'man.png' ) )
+      @storage = @sstorage = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'storage.png' ) )
+      @crate = @scrate = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'crate.png' ) )
+      @floor = @sfloor = Qt::Image.new( File.join( File.dirname( __FILE__ ), 'floor.png' ) )
+
+      @color_bg = Qt::Brush.new( Qt::white )
+    end
+
+    def on_level_selected( oldlevel, curlevel )
+      oldlevel.del_msg_listener( :level_changed, method(:on_level_changed) ) if oldlevel
+      curlevel.add_msg_listener( :level_changed, method(:on_level_changed) )
+      resizeEvent( Qt::ResizeEvent.new( self.size, self.size ) )
+      update
+    end
+
+    def on_level_changed( changes )
+      p = Qt::Painter.new( self )
+      xoff, yoff = offset( @sokoban.cur_level.map )
+      changes.each do |lc|
+        draw_item( p, @sokoban.cur_level.map.get_pos( lc.old_cell.pos ), xoff + lc.old_cell.pos.x * @tile_size, yoff + lc.old_cell.pos.y * @tile_size )
+        draw_item( p, @sokoban.cur_level.map.get_pos( lc.new_cell.pos ), xoff + lc.new_cell.pos.x * @tile_size, yoff + lc.new_cell.pos.y * @tile_size )
+      end
+    end
+
+    def draw_man( painter, x, y, tile_size = @tile_size )
+      @sman = @man.smoothScale( tile_size, tile_size ) if @sman.width != tile_size
+      painter.drawImage( x, y, @sman )
+    end
+
+    def draw_crate( painter, x, y, tile_size = @tile_size )
+      @scrate = @crate.smoothScale( tile_size, tile_size ) if @scrate.width != tile_size
+      painter.drawImage( x, y, @scrate )
+    end
+
+    def draw_storage( painter, x, y, tile_size = @tile_size )
+      @sstorage = @storage.smoothScale( tile_size, tile_size ) if @sstorage.width != tile_size
+      painter.drawImage( x, y, @sstorage )
+    end
+
+    def draw_wall( painter, x, y, tile_size = @tile_size )
+      @swall = @wall.smoothScale( tile_size, tile_size ) if @swall.width != tile_size
+      painter.drawImage( x, y, @swall )
+    end
+
+    def draw_floor( painter, x, y, tile_size = @tile_size )
+      @sfloor = @floor.smoothScale( tile_size, tile_size ) if @sfloor.width != tile_size
+      painter.drawImage( x, y, @sfloor )
+    end
+
+    def draw_map( painter, map, w = self.width, h = self.height, tile_size = @tile_size )
+      painter.fillRect( 0, 0, w, h, @color_bg )
+      xoff, yoff = offset( map, w, h, tile_size )
+      y = yoff
+      map.each_row do |row|
+        x = xoff
+        row.each do |item|
+          draw_item( painter, item, x, y, tile_size )
+          x += tile_size
+        end
+        y += tile_size
+      end
+    end
+
+    def draw_item( painter, item, x, y, tile_size = @tile_size)
+      case item
+      when Map::Wall
+        draw_wall( painter, x, y, tile_size )
+      when Map::Storage
+        draw_floor( painter, x, y, tile_size )
+        draw_storage( painter, x, y, tile_size )
+      when Map::Crate
+        draw_floor( painter, x, y, tile_size )
+        draw_crate( painter, x, y, tile_size )
+      when Map::Man
+        draw_floor( painter, x, y, tile_size )
+        draw_man( painter, x, y, tile_size )
+      when Map::CrateOnStorage
+        draw_floor( painter, x, y, tile_size )
+        draw_storage( painter, x, y, tile_size )
+        draw_crate( painter, x, y, tile_size )
+      when Map::ManOnStorage
+        draw_floor( painter, x, y, tile_size )
+        draw_storage( painter, x, y, tile_size )
+        draw_man( painter, x, y, tile_size )
+      when Map::Floor
+        draw_floor( painter, x, y, tile_size )
+      end
+    end
+
+    def draw_all( painter, map, w, h )
+      draw_map( painter, map, w, h, tile_size( w, h, map ) )
+    end
+
+    def tile_size( w, h, map )
+      dx = w / map.width
+      dy = h / map.height
+      ( dx > dy ? dy : dx )
+    end
+
+    def offset( map, w = self.width, h = self.height, tile_size = @tile_size )
+      [(w - map.width * tile_size) / 2, (h - map.height * tile_size) / 2]
+    end
+
+    def paintEvent( event )
+      pix = Qt::Pixmap.new( width, height )
+      p = Qt::Painter.new
+      p.begin( pix )
+      draw_map( p, @sokoban.cur_level.map ) if @sokoban && @sokoban.cur_level
+      p.end
+
+      painter = Qt::Painter.new( self )
+      painter.drawPixmap( 0, 0, pix )
+    end
+
+    def resizeEvent( event )
+      @tile_size = tile_size( self.width, self.height, @sokoban.cur_level.map ) if @sokoban && @sokoban.cur_level
+    end
+
+    def keyPressEvent( event )
+      case event.key
+      when Qt::Key_Left then @sokoban.cur_level.move( :left )
+      when Qt::Key_Right then @sokoban.cur_level.move( :right )
+      when Qt::Key_Up then @sokoban.cur_level.move( :up )
+      when Qt::Key_Down then @sokoban.cur_level.move( :down )
+      end
+    end
+
+  end
+
+
+  class SokobanUI < Qt::Widget
+
+    slots 'next_level()', 'prev_level()', 'select_level(int)', 'reset_level()'
+    slots 'next_collection()', 'prev_collection()'
+
+    attr_reader :canvas
+    attr_reader :sokoban
+
+    def initialize( parent )
+      super( parent )
+      @sokoban = Sokoban.new
+      Dir[File.join( File.dirname( __FILE__ ), 'levels', '*.lvl')].sort.each do |file|
+        @sokoban.load_level_collection( File.read( file ), File.basename( file, '.*').capitalize.tr( '_', ' ') )
+      end
+      @sokoban.add_msg_listener( :level_selected, method(:on_level_selected) )
+      @canvas = SokobanCanvas.new( self, @sokoban )
+      @sokoban.select_level( 0, 0 )
+
+      layout = Qt::HBoxLayout.new( self )
+      layout.addWidget( @canvas )
+    end
+
+    def next_collection
+      @sokoban.next_collection
+    end
+
+    def prev_collection
+      @sokoban.prev_collection
+    end
+
+    def next_level
+      @sokoban.next_level
+    end
+
+    def prev_level
+      @sokoban.prev_level
+    end
+
+    def select_level( calc_index )
+      @sokoban.select_level( calc_index % 1000, calc_index / 1000 )
+    end
+
+    def reset_level
+      @sokoban.cur_level.reset
+      @canvas.update
+    end
+
+    def undo( info )
+      info.each do |lc|
+        @sokoban.cur_level.map.set_pos( lc.old_cell.pos, lc.old_cell.old_obj )
+        @sokoban.cur_level.map.set_pos( lc.new_cell.pos, lc.new_cell.old_obj )
+      end
+      @sokoban.cur_level.recalc_man_pos
+      @canvas.update
+    end
+
+    def redo( info )
+      info.reverse.each do |lc|
+        @sokoban.cur_level.map.set_pos( lc.old_cell.pos, lc.old_cell.new_obj )
+        @sokoban.cur_level.map.set_pos( lc.new_cell.pos, lc.new_cell.new_obj )
+      end
+      @sokoban.cur_level.recalc_man_pos
+      @canvas.update
+    end
+
+    def set_undo_manager( manager )
+      @manager.del_msg_listener( :undo, method(:undo) ) if @manager
+      @manager.del_msg_listener( :redo, method(:redo) ) if @manager
+      @manager = manager
+      @manager.add_msg_listener( :undo, method(:undo) )
+      @manager.add_msg_listener( :redo, method(:redo) )
+    end
+
+    def on_level_selected( oldlevel, curlevel )
+      oldlevel.del_msg_listener( :level_changed, method(:on_level_changed) ) if oldlevel
+      curlevel.add_msg_listener( :level_changed, method(:on_level_changed) )
+      @manager.clear if @manager
+    end
+
+    def on_level_changed( changes )
+      @manager.add_undo_info( changes )
+    end
+
+  end
+
+
+  class SokobanGame < Smagacor::GamePlugin
+
+    def initialize( parent, gameinfo )
+      @parent = parent
+      @widget = SokobanUI.new( parent )
+      Qt::MessageBox.information( parent, "Credits", "All included Sokoban levels have been made by David W. Skinner (sasquatch@bentonrea.com)" )
+    end
+
+    def game_widget
+      @widget
+    end
+
+    def set_undo_manager( manager )
+      @widget.set_undo_manager( manager )
+    end
+
+    def menu
+      colmenu = Qt::PopupMenu.new( @parent )
+      oldcollection = nil
+      menu = nil
+      @widget.sokoban.each_with_index do |collection, col_index, level, level_index|
+        if oldcollection != collection
+          menu = Qt::PopupMenu.new( @parent )
+          colmenu.insertItem( collection.name, menu )
+          oldcollection = collection
+        end
+
+        icon = level_pix( collection, level, level_index )
+        item = menu.insertItem( icon, @widget, SLOT('select_level(int)') ) #"Level #{level.map.name} (#{level_index+1})"
+        #TODO use small icon + text in menu item, big icon in whatsthis text
+        menu.setWhatsThis( item, "Hallo #{level_index}")
+        menu.setItemParameter( item, col_index * 1000 + level_index )
+      end
+
+      levelmenu = Qt::PopupMenu.new( @parent )
+      levelmenu.insertItem( "Select level", colmenu )
+      levelmenu.insertItem( "Reset level", @widget, SLOT('reset_level()'), Qt::KeySequence.new( Qt::Key_Escape ) )
+      levelmenu.insertItem( "Next collection", @widget, SLOT('next_collection()') )
+      levelmenu.insertItem( "Previous collection", @widget, SLOT('prev_collection()') )
+      levelmenu.insertItem( "Next level in collection", @widget, SLOT('next_level()'), Qt::KeySequence.new( Qt::Key_N ) )
+      levelmenu.insertItem( "Previous level in collection", @widget, SLOT('prev_level()'), Qt::KeySequence.new( Qt::Key_P ) )
+      levelmenu
+    end
+
+    #######
+    private
+    #######
+
+    def level_pix( collection, level, level_index )
+      cachefile = File.join( Smagacor::Config.homepath, 'sokoban', 'level_icon_cache', collection.name + level_index.to_s )
+      if File.exists?( cachefile )
+        Qt::Pixmap.new( cachefile )
+      else
+        tilesize = @widget.canvas.tile_size( 50, 50, level.map )
+        painter = Qt::Painter.new
+        icon = Qt::Pixmap.new( tilesize*level.map.width, tilesize*level.map.height )
+        painter.begin( icon )
+        @widget.canvas.draw_all( painter, level.map, icon.width, icon.height )
+        painter.end
+        FileUtils.makedirs( File.dirname( cachefile ) )
+        icon.save( cachefile, "PNG" )
+        icon
+      end
+    end
+
+  end
+
+
+end