Problem with double-script

EDITED on Nessiah's suggestion 
This script simulates a slot machine that can be called even in battle. The problem is that after having set all of my favourite icons in the slot, I can't choose which of them put in a certain slot, but only how many of them, so including always the firsts.

Spoiler for:

#===============================================================================
#
# Shanghai Simple Script - Minigame Slot Machine
# Last Date Updated: 2010.05.18
# Level: Normal
#
# This is a minigame script. It's easy to play. Press Z to stop each individual
# slot and try to line up all three within the five possible combinations.
#===============================================================================
# Instructions
# -----------------------------------------------------------------------------
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ? Materials but above ? Main. Remember to save.
#
# Do a script call for
#   $game_variables[1] = slot_machine(x, y)
#
# x is the length of the slot reel where the longer it is, the more items there
# are and y is the cursor speed. Works with Battle Engine Melody.
#===============================================================================
 
$imported = {} if $imported == nil
$imported["MinigameSlotMachine"] = true

module SSS
  # This is the image file from the system folder used for the slot machine.
  SLOT_MACHINE_SHEET = "MiniGameSlots"
  # These are the sound effects for the slot machine game.
  SLOT_MACHINE_STOP  = RPG::SE.new("Open3", 100, 120)
  SLOT_MACHINE_CLICK = RPG::SE.new("Switch1", 100, 100)
  SLOT_MACHINE_LUCKY = RPG::SE.new("Chime2", 100, 120)
  SLOT_MACHINE_MISS  = RPG::SE.new("Buzzer2", 100, 100)
  # This hash contains data used to refer icons.
  SLOT_ICONS ={
     1 => 591,
     2 => 590,
     3 => 589,
     4 => 205,
     5 => 203,
     6 => 201,
     7 => 204,
     8 => 200,
  } # Remove this and perish.
module SPRITESET
  #--------------------------------------------------------------------------
  # * Slot Machine Game
  #--------------------------------------------------------------------------
  def slot_machine(possibilities = SSS::SLOT_ICONS.size, speed = 5)
    @slot_possibilities = [possibilities, 3].max
    @slot_speed = [[speed, 1].max, 20].min
    @slot_stops = 0
    @start_ticks = 80
    @stop_ticks = 60
    create_slot_machine_sprites
    create_slot_machine_planes
  end
  #--------------------------------------------------------------------------
  # * Create Slot Machine Sprites
  #--------------------------------------------------------------------------
  def create_slot_machine_sprites
    vp = @viewportC.nil? ? @viewport3 : @viewportC
    @slot_machine_sprite = Sprite_Base.new(vp)
    bitmap1 = Bitmap.new(240, 264)
    bitmap2 = Cache.system(SSS::SLOT_MACHINE_SHEET)
    # Make the Main Body
    rect = Rect.new(0, 0, 240, 240)
    bitmap1.blt(0, 0, bitmap2, rect)
    # Make the Instructions
    unless $game_temp.in_battle
      rect = Rect.new(0, 240, 192, 24)
      bitmap1.blt(24, 240, bitmap2, rect)
    end
    # Apply Sprite
    @slot_machine_sprite.bitmap = bitmap1
    @slot_machine_sprite.x = (Graphics.width - 240) / 2
    @slot_machine_sprite.y = Graphics.height - 368
    # Make Sounds
    @stop_sound = SSS::SLOT_MACHINE_STOP
    @click_sound = SSS::SLOT_MACHINE_CLICK
    @slot_machine_sprite.opacity = 0
  end
  #--------------------------------------------------------------------------
  # * Dispose Slot Machine Sprites
  #--------------------------------------------------------------------------
  def dispose_slot_machine_sprites
    unless @slot_machine_sprite.nil?
      @slot_machine_sprite.bitmap.dispose
      @slot_machine_sprite.dispose
      @slot_machine_sprite = nil
    end
    unless @slot_results_sprite.nil?
      @slot_results_sprite.bitmap.dispose
      @slot_results_sprite.dispose
      @slot_results_sprite = nil
    end
    unless @slot_viewport1.nil?
      @slot_viewport1.dispose
      @slot_viewport1 = nil
      @slot_plane1.bitmap.dispose
      @slot_plane1.dispose
      @slot_plane1 = nil
      @slot_viewport2.dispose
      @slot_viewport2 = nil
      @slot_plane2.bitmap.dispose
      @slot_plane2.dispose
      @slot_plane2 = nil
      @slot_viewport3.dispose
      @slot_viewport3 = nil
      @slot_plane3.bitmap.dispose
      @slot_plane3.dispose
      @slot_plane3 = nil
    end
  end
  #--------------------------------------------------------------------------
  # * Create Slot Machine Planes
  #--------------------------------------------------------------------------
  def create_slot_machine_planes
    # Create Planes
    rect = Rect.new(0, 0, 44, 140)
    rect.x = @slot_machine_sprite.x+48
    rect.y = @slot_machine_sprite.y+52
    vp = @viewportC.nil? ? @viewport3 : @viewportC
    @slot_viewport1 = Viewport.new(rect.clone)
    @slot_viewport1.z = vp.z
    @slot_plane1 = Plane.new(@slot_viewport1)
    rect.x = @slot_machine_sprite.x+98
    rect.y = @slot_machine_sprite.y+52
    @slot_viewport2 = Viewport.new(rect.clone)
    @slot_viewport2.z = vp.z
    @slot_plane2 = Plane.new(@slot_viewport2)
    rect.x = @slot_machine_sprite.x+148
    rect.y = @slot_machine_sprite.y+52
    @slot_viewport3 = Viewport.new(rect.clone)
    @slot_viewport3.z = vp.z
    @slot_plane3 = Plane.new(@slot_viewport3)
    bitmap0 = Cache.system("IconSet")
    # Make Plane Bitmap 1
    bitmap1 = Bitmap.new(48, @slot_possibilities * 48)
    @slot_array1 = []
    n = 1
    @slot_possibilities.times do
      @slot_array1.insert(rand(@slot_array1.size+1), n)
      n += 1
    end
    for id in @slot_array1
      icon_index = SSS::SLOT_ICONS[id]
      rect1 = Rect.new(-2, (@slot_array1.index(id)) * 48 - 4, 48, 48)
      rect2 = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      bitmap1.stretch_blt(rect1, bitmap0, rect2)
      @slot_plane1.bitmap = bitmap1
    end
    # Make Plane Bitmap 2
    bitmap2 = Bitmap.new(48, @slot_possibilities * 48)
    @slot_array2 = []
    n = 1
    @slot_possibilities.times do
      @slot_array2.insert(rand(@slot_array2.size+1), n)
      n += 1
    end
    for id in @slot_array2
      icon_index = SSS::SLOT_ICONS[id]
      rect1 = Rect.new(-2, (@slot_array2.index(id)) * 48 - 4, 48, 48)
      rect2 = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      bitmap2.stretch_blt(rect1, bitmap0, rect2)
      @slot_plane2.bitmap = bitmap2
    end
    # Make Plane Bitmap 3
    bitmap3 = Bitmap.new(48, @slot_possibilities * 48)
    @slot_array3 = []
    n = 1
    @slot_possibilities.times do
      @slot_array3.insert(rand(@slot_array3.size+1), n)
      n += 1
    end
    for id in @slot_array3
      icon_index = SSS::SLOT_ICONS[id]
      rect1 = Rect.new(-2, (@slot_array3.index(id)) * 48 - 4, 48, 48)
      rect2 = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
      bitmap3.stretch_blt(rect1, bitmap0, rect2)
      @slot_plane3.bitmap = bitmap3
    end
    @slot_plane1.opacity = 0
    @slot_plane2.opacity = 0
    @slot_plane3.opacity = 0
  end
  #--------------------------------------------------------------------------
  # * Update Slot Machine
  #--------------------------------------------------------------------------
  def update_slot_machine
    case @start_ticks
    when 61..80
      slot_speed = 0
      @slot_machine_sprite.opacity += 16
      @slot_plane1.opacity += 16
      @slot_plane2.opacity += 16
      @slot_plane3.opacity += 16
    when 41..60
      slot_speed = [@slot_speed / 4, 1].max
    when 21..40
      slot_speed = [@slot_speed / 2, 1].max
    when 1..20
      slot_speed = [@slot_speed * 3 / 4, 1].max
    when 0
      slot_speed = @slot_speed
    end
    @slot_machine_sprite.update
    @start_ticks -= 1 if @start_ticks > 0
    @slot_plane1.oy -= slot_speed if @slot_stops < 1
    @slot_plane2.oy -= slot_speed if @slot_stops < 2
    @slot_plane3.oy -= slot_speed if @slot_stops < 3
    @sound_ticks = 24 if @sound_ticks.nil? or @sound_ticks <= 0
    @sound_ticks -= slot_speed
    @click_sound.play if @sound_ticks <= 0 and @slot_stops < 3
    stop_slot if @start_ticks <= 0 and Input.trigger?(Input::C)
    slot_correction
  end
  #--------------------------------------------------------------------------
  # * Stop Slot
  #--------------------------------------------------------------------------
  def stop_slot
    return if @slot_stops == 3
    @stop_sound.play
    @slot_stops += 1
    bitmap = Cache.system(SSS::SLOT_MACHINE_SHEET)
    rect = Rect.new(192, 240, 48, 48)
    case @slot_stops
    when 1
      @slot_machine_sprite.bitmap.blt(46, 193, bitmap, rect)
    when 2
      @slot_machine_sprite.bitmap.blt(96, 193, bitmap, rect)
    when 3
      @slot_machine_sprite.bitmap.blt(146, 193, bitmap, rect)
    end
  end
  #--------------------------------------------------------------------------
  # * Slot Correction
  #--------------------------------------------------------------------------
  def slot_correction
    if @slot_stops >= 1 and @slot_plane1.oy % 48 != 0
      case @slot_plane1.oy % 48
      when 39..47; value = [5, @slot_speed].min
      when 29..38; value = [4, @slot_speed].min
      when 19..28; value = [3, @slot_speed].min
      when  9..18; value = [2, @slot_speed].min
      else; value = 1
      end
      @slot_plane1.oy -= value
    end
    if @slot_stops >= 2 and @slot_plane2.oy % 48 != 0
      case @slot_plane2.oy % 48
      when 39..47; value = [5, @slot_speed].min
      when 29..38; value = [4, @slot_speed].min
      when 19..28; value = [3, @slot_speed].min
      when  9..18; value = [2, @slot_speed].min
      else; value = 1
      end
      @slot_plane2.oy -= value
    end
    if @slot_stops >= 3 and @slot_plane3.oy % 48 != 0
      case @slot_plane3.oy % 48
      when 39..47; value = [5, @slot_speed].min
      when 29..38; value = [4, @slot_speed].min
      when 19..28; value = [3, @slot_speed].min
      when  9..18; value = [2, @slot_speed].min
      else; value = 1
      end
      @slot_plane3.oy -= value
    end
  end
  #--------------------------------------------------------------------------
  # * Slot Machine Stopped
  #--------------------------------------------------------------------------
  def slot_machine_stopped
    return false if @slot_stops < 3
    return false unless @slot_plane1.oy % 48 == 0
    return false unless @slot_plane2.oy % 48 == 0
    return false unless @slot_plane3.oy % 48 == 0
    @stop_ticks -= 1
    return false unless @stop_ticks < 0
    return true
  end
  #--------------------------------------------------------------------------
  # * Finish Slot Machine
  #--------------------------------------------------------------------------
  def finish_slot_machine
    results = slot_machine_results
    # Create Victory Image
    vp = @viewportC.nil? ? @viewport3 : @viewportC
    @slot_results_sprite = Sprite_Base.new(vp)
    bitmap1 = Bitmap.new(96, 24)
    bitmap2 = Cache.system(SSS::SLOT_MACHINE_SHEET)
    if results > 0
      SSS::SLOT_MACHINE_LUCKY.play
      rect = Rect.new(92, 264, 96, 24)
    end
    if results <= 0
      SSS::SLOT_MACHINE_MISS.play
      rect = Rect.new(0, 264, 96, 24)
    end
    bitmap1.blt(0, 0, bitmap2, rect)
    @slot_results_sprite.bitmap = bitmap1
    @slot_results_sprite.ox = 48
    @slot_results_sprite.oy = 24
    @slot_results_sprite.x = Graphics.width/2
    @slot_results_sprite.y = Graphics.height/2
    @slot_results_sprite.zoom_x = 2.0
    @slot_results_sprite.zoom_y = 2.0
    # Fade out Slot Machine
    loop do
      @slot_machine_sprite.opacity -= 16
      @slot_plane1.opacity -= 16
      @slot_plane2.opacity -= 16
      @slot_plane3.opacity -= 16
      @slot_machine_sprite.update
      @slot_results_sprite.y -= 1
      @slot_results_sprite.update
      $scene.update_basic
      break if @slot_machine_sprite.opacity < 1
    end
    loop do
      @slot_results_sprite.opacity -= 8
      @slot_results_sprite.update
      $scene.update_basic
      break if @slot_results_sprite.opacity < 1
    end
    dispose_slot_machine_sprites
    return results
  end
  #--------------------------------------------------------------------------
  # * Slot Machine Results
  #--------------------------------------------------------------------------
  def slot_machine_results
    results =

    sa = []
    # Calculate Slot Positions for Slot 1
    top_slot = @slot_array1[@slot_plane1.oy / 48 % @slot_possibilities]
    mid_slot = @slot_array1[(@slot_plane1.oy + 48) / 48 % @slot_possibilities]
    low_slot = @slot_array1[(@slot_plane1.oy + 96) / 48 % @slot_possibilities]
    sa.push(top_slot, mid_slot, low_slot)
    # Calculate Slot Positions for Slot 2
    top_slot = @slot_array2[@slot_plane2.oy / 48 % @slot_possibilities]
    mid_slot = @slot_array2[(@slot_plane2.oy + 48) / 48 % @slot_possibilities]
    low_slot = @slot_array2[(@slot_plane2.oy + 96) / 48 % @slot_possibilities]
    sa.push(top_slot, mid_slot, low_slot)
    # Calculate Slot Positions for Slot 3
    top_slot = @slot_array3[@slot_plane3.oy / 48 % @slot_possibilities]
    mid_slot = @slot_array3[(@slot_plane3.oy + 48) / 48 % @slot_possibilities]
    low_slot = @slot_array3[(@slot_plane3.oy + 96) / 48 % @slot_possibilities]
    sa.push(top_slot, mid_slot, low_slot)
    # Push matches to results
    for i in 1..@slot_possibilities
      results.push(i) if sa[0] == i and sa[0] == sa[3] and sa[0] == sa[6]
      results.push(i) if sa[0] == i and sa[0] == sa[4] and sa[0] == sa[8]
      results.push(i) if sa[1] == i and sa[1] == sa[4] and sa[1] == sa[7]
      results.push(i) if sa[2] == i and sa[2] == sa[4] and sa[2] == sa[6]
      results.push(i) if sa[2] == i and sa[2] == sa[5] and sa[2] == sa[8]
    end
    return results.max
  end
end
end

#==============================================================================
# ** Game_Interpreter
#==============================================================================
 
class Game_Interpreter
  #--------------------------------------------------------------------------
  # * Slot Machine Game
  #--------------------------------------------------------------------------
  def slot_machine(possibilities = SSS::SLOT_ICONS.size, speed = 5)
    return 0 unless $scene.is_a?(Scene_Map) or $scene.is_a?(Scene_Battle)
    return $scene.slot_machine(possibilities, speed)
  end
end
 
#==============================================================================
# ** Spriteset_Map
#==============================================================================
 
class Spriteset_Map
  include SSS::SPRITESET
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  alias dispose_sss_spriteset_map_slots dispose unless $@
  def dispose
    dispose_sss_spriteset_map_slots
    dispose_slot_machine_sprites
  end
end
 
#==============================================================================
# ** Spriteset_Battle
#==============================================================================
 
class Spriteset_Battle
  include SSS::SPRITESET
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  alias dispose_sss_spriteset_battle_slots dispose unless $@
  def dispose
    dispose_sss_spriteset_battle_slots
    dispose_slot_machine_sprites
  end
end
 
#==============================================================================
# ** Scene_Map
#==============================================================================
 
class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :spriteset
  #--------------------------------------------------------------------------
  # * Slot Machine
  #--------------------------------------------------------------------------
  def slot_machine(possibilities = SSS::SLOT_ICONS.size, speed = 5)
    @spriteset.slot_machine(possibilities, speed)
    loop do
      update_basic
      @spriteset.update_slot_machine
      break if @spriteset.slot_machine_stopped
    end
    return @spriteset.finish_slot_machine
  end
end
 
#==============================================================================
# ** Scene_Battle
#==============================================================================
 
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :spriteset
  #--------------------------------------------------------------------------
  # * Slot Machine
  #--------------------------------------------------------------------------
  def slot_machine(possibilities = SSS::SLOT_ICONS.size, speed = 5)
    @spriteset.slot_machine(possibilities, speed)
    loop do
      update_basic
      @spriteset.update_slot_machine
      break if @spriteset.slot_machine_stopped
    end
    return @spriteset.finish_slot_machine
  end
end

#===============================================================================
#
# END OF FILE
#
#===============================================================================

The only idea I had was that to doublicate the script and make 2 lists of icons, but i can't modify the call code

$game_variables[1] = slot_machine(icons, speed)

into a new one ( e.g. $game_variables[1] = slot_machine2(icons, speed) ). Could anyone tell me how modify the call phrase of this script, or else solving my problem with 2 slot machines?
Thanks in advance.

Little bump 

I think this is more fitting for script request support. Please edit the topic based on the guidelines or existing topics to get an idea.
Moving now~