#==============================================================================#
# ** ISS - SwapXT ( Remixed )
#==============================================================================# 
# ** Date Created  : 05/12/2011
# ** Date Modified : 05/13/2011
# ** Original By   : Marco Di Antonio (bulletxt@gmail.com) (BulletXt)
# ** Rewritten By  : IceDragon
# ** ID            : R01
# ** Version       : 0.9
#==============================================================================# 
# ============================================================================ #
# // This is SwapXT script that must be put in your VX game script section. // #
# // It's Plug&Play.                                                        // #
# // Use SwapXT application to do swaps once you put this into your VX game.// #
# ============================================================================ #
# Currently, realtime swapping isn't supported sorry about that ,x,
$imported = {} if $imported == nil
$imported["ISS-SwapXT"] = true
#==============================================================================#
# ISS::SwapXT 
#==============================================================================#
module ISS
  module SwapXT 
    EVENT_SWAPPING_SWITCH_ID = nil
  end
#==============================================================================#
# SwapXT::Game_SwapXT
#==============================================================================# 
  class SwapXT::Game_SwapXT
    
  #--------------------------------------------------------------------------#
  # * Constants
  #--------------------------------------------------------------------------#    
    RMVX_FEXTENSION      = ".rvdata"
    SWAPXT_FEXTENSION    = ".stx"
    SWAPXT_MAIN_PATH     = "swapxt/"
    PROFILE_TILE_PATH    = "tiles/"
    PROFILE_PASS_PATH    = "passages/"
    DEF_TILE_PATH        = "Graphics/System/"
    DEF_EXTRA_TILEFOLDER = "extra_tiles/"
    DEF_PASSAGE_PATH     = "Graphics/System/"
    DEF_EXTRA_PASSFOLDER = "extra_tiles/"
    FILEEMPTY_STRING     = "empty::*::"
    DEFAULT_TILES        = Array.new(9).map! { "" } # // I have no idea why I did this...
    DEFAULT_TILES[0]     = "TileA1"
    DEFAULT_TILES[1]     = "TileA2"
    DEFAULT_TILES[2]     = "TileA3"
    DEFAULT_TILES[3]     = "TileA4"
    DEFAULT_TILES[4]     = "TileA5"
    DEFAULT_TILES[5]     = "TileB"
    DEFAULT_TILES[6]     = "TileC"
    DEFAULT_TILES[7]     = "TileD"
    DEFAULT_TILES[8]     = "TileE"
    
  #--------------------------------------------------------------------------#
  # * Public Instance Variables
  #--------------------------------------------------------------------------#   
    attr_accessor :loaded_system
    attr_accessor :swap_tiles
    
  #--------------------------------------------------------------------------#
  # * method :initialize
  #--------------------------------------------------------------------------#     
    def initialize()
      setup( -1 )
    end
    
  #--------------------------------------------------------------------------#
  # * method :setup
  #--------------------------------------------------------------------------#    
    def setup( map_id )
      @swap_tiles       = Array.new(9).map! { FILEEMPTY_STRING }
      @swap_passages    = FILEEMPTY_STRING # // System.rvdata name
      @swap_realtime    = false
      @swap_tile_profile= false
      @swap_pass_profile= false
      @map_id           = map_id
      @loaded_system    = nil
      load_tile_profile( @map_id )
      load_passage_profile( @map_id )
      load_system_data()
    end  
    
  #--------------------------------------------------------------------------#
  # * method :tile_bitmapname
  #--------------------------------------------------------------------------#       
    def tile_bitmapname( t, defal=false )
      case t
      when 0, :a1
        return DEFAULT_TILES[0] if @swap_tiles[0] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[0] )  
      when 1, :a2
        return DEFAULT_TILES[1] if @swap_tiles[1] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[1] )  
      when 2, :a3
        return DEFAULT_TILES[2] if @swap_tiles[2] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[2] )  
      when 3, :a4
        return DEFAULT_TILES[3] if @swap_tiles[3] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[3] )  
      when 4, :a5
        return DEFAULT_TILES[4] if @swap_tiles[4] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[4] )  
      when 5, :b
        return DEFAULT_TILES[5] if @swap_tiles[5] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[5] )  
      when 6, :c
        return DEFAULT_TILES[6] if @swap_tiles[6] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[6] )  
      when 7, :d  
        return DEFAULT_TILES[7] if @swap_tiles[7] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[7] )  
      when 8, :e
        return DEFAULT_TILES[8] if @swap_tiles[8] == FILEEMPTY_STRING or defal
        return sprintf( "%s%s", DEF_EXTRA_TILEFOLDER, @swap_tiles[8] )  
      end  
    end
    
  #--------------------------------------------------------------------------#
  # * method :load_tile_profile
  #--------------------------------------------------------------------------#     
    def load_tile_profile( map_id )
      ext = SWAPXT_FEXTENSION
      pth = SWAPXT_MAIN_PATH
      tpth= PROFILE_TILE_PATH
      mid = map_id
      nm = sprintf( "%s%s%s%s", pth, tpth, mid, ext )
      if FileTest.exist?( nm )
        @swap_tile_profile = true ; i = 0
        File.read( nm ).split( "\n" ).each { |t|
          @swap_tiles[i] = t ; i += 1
        }  
      end  
    end
    
  #--------------------------------------------------------------------------#
  # * method :load_passage_profile
  #--------------------------------------------------------------------------#     
    def load_passage_profile( map_id )
      ext = SWAPXT_FEXTENSION
      pth = SWAPXT_MAIN_PATH
      ppth= PROFILE_PASS_PATH
      mid = map_id
      nm = sprintf( "%s%s%s%s", pth, ppth, mid, ext )
      if FileTest.exist?( nm )
        @swap_pass_profile = true
        @swap_passages = ( File.read( nm ).split( "\n" ) )[0]
      end
    end
    
  #--------------------------------------------------------------------------#
  # * method :load_system_data
  #--------------------------------------------------------------------------#    
    def load_system_data()
      return if @swap_passages == FILEEMPTY_STRING
      ext = RMVX_FEXTENSION
      pth = DEF_PASSAGE_PATH     
      ppth= DEF_EXTRA_PASSFOLDER 
      nm  = sprintf( "%s%s%s%s", pth, ppth, @swap_passages, ext)
      if FileTest.exist?( nm )
        @loaded_system = load_data( nm )
      else
        m = ISS::SwapXT::ErrorHandler::ERROR_MESSAGES["SystemDataDoesntExist"]
        m = sprintf( m, @swap_passages + ext )
        ::ISS::SwapXT::ErrorHandler.throw_error( m )
        return
      end  
    end
    
  #--------------------------------------------------------------------------#
  # * class method :startup_error_checking
  #--------------------------------------------------------------------------#    
    def self.startup_error_checking()
      if ::ISS::SwapXT::ErrorHandler.tile_error?()
        m = ISS::SwapXT::ErrorHandler::ERROR_MESSAGES["SwappedTileExists"]
        ::ISS::SwapXT::ErrorHandler.throw_error( m )
        return
      end 
      if ::ISS::SwapXT::ErrorHandler.passage_error?()
        m = ISS::SwapXT::ErrorHandler::ERROR_MESSAGES["SwappedPassageExists"]
        ::ISS::SwapXT::ErrorHandler.throw_error( m )
        return
      end
    end
    
  end # // SwapXT::Game_SwapXT
#==============================================================================#
# SwapXT::ErrorHandler
#==============================================================================#  
  class SwapXT::ErrorHandler
    
  #--------------------------------------------------------------------------#
  # * Constants
  #--------------------------------------------------------------------------#
    EXTENSIONS = [".png"]
    TILENAMES  = { 
      0 => "A1",
      1 => "A2",
      2 => "A3",
      3 => "A4",
      4 => "A5",
      5 => "B",
      6 => "C",
      7 => "D",
      8 => "E"
    } # // Do Not Remove
    SWAP_PREFILENAME      = "swapped_"
    PASSAGE_WARN_FILENAME = "passage_warning"
    
    ERROR_HEADER   = "SwapXT Error Encountered:"
    ERROR_MESSAGES = { 
    # // Swapped tiles exists message
      "SwappedTileExists" => %Q(
      #{ERROR_HEADER}
      You are not allowed to start your game with swapped tilesets. 
      You must unload your tilesets with SwapXT application first. 
      Open SwapXT, click at top Tools->Restore all Tilesets
      ),
    # // Swapped passage exists message
      "SwappedPassageExists" => %Q(
      #{ERROR_HEADER}
      You are not allowed to start your game with swapped passage settings. 
      You must unload your passage setting with SwapXT application first. 
      Open SwapXT, go on PassageSetting tab and click on Restore to Default.
      ),
      "SystemDataDoesntExist"=> %Q(
      #{ERROR_HEADER}
      Cannot load passage data
      %s does not exist. Please check to ensure the file is spelt correctly,
      or if the file exists.
      )
    }
    
  #--------------------------------------------------------------------------#
  # * class method :tile_error?
  #--------------------------------------------------------------------------#    
    def self.tile_error?()
      spf = SWAP_PREFILENAME
      tln = TILENAMES
      pth = ::ISS::SwapXT::Game_SwapXT::DEF_TILE_PATH
      # ---------------------------------------------------------------------- #
      tln.keys.each { |i|
        EXTENSIONS.each { |ext|
          nm = sprintf( "%s%s%s%s", pth, spf, tln[i], ext)
          return true if FileTest.exist?( nm ) 
        } # // EXTENSIONS
      } # // TILENAMES.keys 
      # ---------------------------------------------------------------------- #
      return false # // No problems
    end
    
  #--------------------------------------------------------------------------#
  # * class method :passage_error?
  #--------------------------------------------------------------------------#     
    def self.passage_error?()
      pwf = PASSAGE_WARN_FILENAME
      pth = ::ISS::SwapXT::Game_SwapXT::SWAPXT_MAIN_PATH
      ext = ::ISS::SwapXT::Game_SwapXT::SWAPXT_FEXTENSION
      # ---------------------------------------------------------------------- #
      nm  = sprintf( "%s%s%s", pth, pwf, ext )
      # ---------------------------------------------------------------------- #
      return true if FileTest.exist?( nm )
      # ---------------------------------------------------------------------- #
      return false # // No problems
    end
    
  #--------------------------------------------------------------------------#
  # * class method :throw_warning
  #--------------------------------------------------------------------------#     
    def self.throw_warning( string ) ; p string end
  #--------------------------------------------------------------------------#
  # * class method :throw_error
  #--------------------------------------------------------------------------#       
    def self.throw_error( string ) ; print string ; exit end
  
  end # // SwapXT::ErrorHandler
  
end # // ISS

#==============================================================================#
# Game_Map
#==============================================================================#
class Game_Map
 
  #--------------------------------------------------------------------------#
  # * alias method :setup
  #--------------------------------------------------------------------------# 
  alias iss_swapxt_gmp_setup setup unless $@
  def setup( map_id )
    iss_swapxt_gmp_setup( map_id )
    $game_swapxt.setup( map_id )
    unless $game_swapxt.loaded_system.nil?()
      @passages = $game_swapxt.loaded_system.passages 
    end  
  end
  
end

#==============================================================================#
# Scene_Title
#==============================================================================#
class Sprite_Character < Sprite_Base
  
  #--------------------------------------------------------------------------#
  # * overwrite method :tileset_bitmap
  #--------------------------------------------------------------------------# 
  def tileset_bitmap( tile_id )
    set_number = tile_id / 256
    if ::ISS::SwapXT::EVENT_SWAPPING_SWITCH_ID.nil?() ; defal = false
    else ; defal = $game_switches[::ISS::SwapXT::EVENT_SWAPPING_SWITCH_ID] ; end
    btmpnm = $game_swapxt.tile_bitmapname( set_number+5, defal )
    return Cache.system( btmpnm ) if set_number >= 0 && set_number <= 4
    return nil
  end  
  
end

#==============================================================================#
# Spriteset_Map
#==============================================================================#
class Spriteset_Map
  
  #--------------------------------------------------------------------------#
  # * alias method :create_tilemap
  #--------------------------------------------------------------------------#  
  alias iss_swapxt_spmp_create_tilemap create_tilemap unless $@
  def create_tilemap()
    iss_swapxt_spmp_create_tilemap()
    set_tilemapBitmaps( @tilemap )
  end
  
  #--------------------------------------------------------------------------#
  # * new method :set_tilemapBitmaps
  #--------------------------------------------------------------------------#  
  def set_tilemapBitmaps( tilemap )
    gsxt = $game_swapxt
    9.times { |i|
      tilemap.bitmaps[i] = Cache.system( gsxt.tile_bitmapname( i, false ) )
    }
  end
  
end

#==============================================================================#
# Scene_Title
#==============================================================================#
class Scene_Title < Scene_Base
  
  #--------------------------------------------------------------------------#
  # * alias method :start
  #--------------------------------------------------------------------------#  
  alias iss_swapxt_scnt_start start unless $@
  def start()
    iss_swapxt_scnt_start()
    ::ISS::SwapXT::Game_SwapXT.startup_error_checking()
  end
  
  #--------------------------------------------------------------------------#
  # * alias method :create_game_objects
  #--------------------------------------------------------------------------#    
  alias iss_swapxt_scnt_create_game_objects create_game_objects unless $@
  def create_game_objects()
    iss_swapxt_scnt_create_game_objects()
    $game_swapxt = ISS::SwapXT::Game_SwapXT.new()
  end
  
end

#==============================================================================#
# Scene_File
#==============================================================================#
class Scene_File < Scene_Base
  
  #--------------------------------------------------------------------------#
  # * alias method :write_save_data
  #--------------------------------------------------------------------------# 
  alias iss_swapxt_scnf_write_save_data write_save_data unless $@
  def write_save_data( file )
    iss_swapxt_scnf_write_save_data( file )
    Marshal.dump( $game_swapxt,      file )
  end  
  
  #--------------------------------------------------------------------------#
  # * alias method :read_save_data
  #--------------------------------------------------------------------------#
  alias iss_swapxt_scnf_read_save_data read_save_data unless $@
  def read_save_data( file )
    iss_swapxt_scnf_read_save_data( file )
    $game_swapxt    = Marshal.load( file )
  end
  
end

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