ТЕМА: RGSS+

#===========RGSS+ (v.1.08)==============
#-------------------------------------------------------------------------------
#Различные добавки к RGSS.
#Версия набора: 1.08 от 27.08.2014
# Array:
#   ~random - возвращает случайный элемент из массива
#   ~sample - тоже самое
#   ~last - возвращает последний элемент массива
#   ~size= - строго устанавливает количество элементов
# Integer:
#   ~sign - возвращает знак для числа (положительное/отрицательное/ноль)
#   ~factorial - возвращает факториал числа
#   ~combine - пересчитывает количество комбинаций от K до текущего
# Sprite:
#   ~dispose - добавляет удаление битмапа перед удалением спрайта
#   ~text_color - для добавления в спрайт текста с параметрами
#			цвета как в window_base, то есть:
#     ~~normal_color
#     ~~disabled_color
#     ~~system_color
#     ~~crisis_color
#     ~~knockout_color
#   ~break_into_lines - разрезает строку текста на несколько
#   ~symbolize - превращает строку в символ правильно
# String:
#   ~to_ary - возвращает массив, где каждый элемент - это один символ из строки
#   ~symbolize - правильно конвертирует в символ
#		Дополнено для работы с кириллицей
#   ~updace - делает буквы ПРОПИСНЫМИ, меняет исходную строку
#   ~downcase - делает буквы строчными, меняет исходную строку
# RPG:
#   ~confirm - вызывает окно для подтверждения действия
#   ~warn - вызывает окно для показа ошибки/уведомления
# Bitmask - полностью скопировано со скрипта от MoonPearl
# Symbol:
#   ~display - правильно конвертирует в строку
# Dir:
#   ~files - возвращает массив файлов в папке
#   ~subdirectories - возвращает массив подкаталогов в папке
#   ~has_subdirectories? - проверяет наличие хотя бы одного подкаталога
# File:
#   ~directory? - проверяет, является ли файл папкой
#-------------------------------------------------------------------------------
$deadelf79_scripts=[] if $deadelf79_scripts==nil
$deadelf79_scripts.push("[rgssplus] ver:1.08:")
#-------------------------------------------------------------------------------
#                               ARRAY
#-------------------------------------------------------------------------------
class Array
  def random
    if self.size!=nil
      ret=rand(self.size)
      return self[ret-1]
    end
    return nil
  end
 
	alias sample random#для совместимости с некоторыми скриптами
 
  def last
    return self[self.size-1]
  end
 
  def size=(value)
		return if value==self.size
		new_arr=[]
		if value<self.size
			for index in 0...value
				new_arr<<self[index]
			end
			self.clear
			for index in 0...new_arr.size
				self.push new_arr[index]
			end
		elsif value>self.size
			for index in self.size...value
				self.push nil
			end
		end
	end
end
#-------------------------------------------------------------------------------
#                               INTEGER
#-------------------------------------------------------------------------------
class Integer
	def sign
		if self>0 then
			return 1
		elsif self<0
			return -1
		else
			return 0
		end
	end
 
	# Возвращает значение факториала от переменной self
  def factorial
    f = 1
    for i in 1..self
      f *= i
    end
    return f
  end
 
  # Пересчитывает количество комбинаций от K до текущего
	#  - k: любое положительное число, которое меньеше и равно текущему
  def combin(k)
    return self.factorial / (k.factorial * (n - k).factorial)
  end
end
#-------------------------------------------------------------------------------
#                               SPRITE
#-------------------------------------------------------------------------------
class Sprite
  alias old_dispose dispose
  def dispose
    if self.bitmap!=nil
      self.bitmap.dispose
    end
    old_dispose
  end
	def text_color(n)
    case n
    when 0
      return Color.new(255, 255, 255, 255)
    when 1
      return Color.new(128, 128, 255, 255)
    when 2
      return Color.new(255, 128, 128, 255)
    when 3
      return Color.new(128, 255, 128, 255)
    when 4
      return Color.new(128, 255, 255, 255)
    when 5
      return Color.new(255, 128, 255, 255)
    when 6
      return Color.new(255, 255, 128, 255)
    when 7
      return Color.new(192, 192, 192, 255)
    else
      normal_color
    end
  end
	def normal_color
    return Color.new(255, 255, 255, 255)
  end
  #--------------------------------------------------------------------------
  # * Get Disabled Text Color
  #--------------------------------------------------------------------------
  def disabled_color
    return Color.new(255, 255, 255, 128)
  end
  #--------------------------------------------------------------------------
  # * Get System Text Color
  #--------------------------------------------------------------------------
  def system_color
    return Color.new(192, 224, 255, 255)
  end
  #--------------------------------------------------------------------------
  # * Get Crisis Text Color
  #--------------------------------------------------------------------------
  def crisis_color
    return Color.new(255, 255, 64, 255)
  end
  #--------------------------------------------------------------------------
  # * Get Knockout Text Color
  #--------------------------------------------------------------------------
  def knockout_color
    return Color.new(255, 64, 0)
  end
end
#-------------------------------------------------------------------------------
#                               STRING
#-------------------------------------------------------------------------------
class String
	# Разрезает строку текста на несколько
	#  - amount: максимальное количество символов в одной строке
  def break_into_lines(amount)
    if self.size <= amount
      yield self
    else
      i = 0
      until i >= self.size
        n = self[i, amount].reverse.index(" ")
        n = amount - (n.nil? ? 0 : n)
        yield self[i, n]
        i += n
      end
    end
  end
 
	# Превращает строку в символ правильно
  def symbolize
    return :empty if self.empty?
    return self.downcase.gsub(" ", "_").to_sym
  end
 
  # Заменяет все строчные буквы прописными
  alias old_upcase upcase
	def upcase
		if self.ascii_only?
			old_upcase
		else
			newstring=self.clone
			newcase=[]
			('А'..'Я').each{ |item|
				newcase+= [ item ]
			}
			index=0
			('а'..'я').each{ |item|
				newstring.gsub!(item) {newcase[ index ]}
				index+=1
			}
			self.gsub!('ё') { 'Ё' }
			return newstring
		end
	end
 
	alias old_upcase! upcase!
	def upcase!
		if self.ascii_only?
			old_upcase!
		else
			newcase=[]
			('А'..'Я').each{ |item|
				newcase+= [ item ]
			}
			index=0
			('а'..'я').each{ |item|
				self.gsub!(item) {newcase[ index ]}
				index+=1
			}
			self.gsub!('ё') { 'Ё' }
			return self
		end
	end
 
	# Заменяет прописные буквы строчными
	alias old_downcase downcase
	def downcase
		if self.ascii_only?
			old_downcase
		else
			newstring=self.clone
			newcase=[]
			('а'..'я').each{ |item|
				newcase+= [ item ]
			}
			index=0
			('А'..'Я').each{ |item|
				newstring.gsub!(item) {newcase[ index ]}
				index+=1
			}
			self.gsub!('Ё') { 'ё' }
			return newstring
		end
	end
 
	alias old_downcase! downcase!
	def downcase!
		if self.ascii_only?
			old_downcase!
		else
			newcase=[]
			('а'..'я').each{ |item|
				newcase+= [ item ]
			}
			index=0
			('А'..'Я').each{ |item|
				self.gsub!(item) {newcase[ index ]}
				index+=1
			}
			self.gsub!('Ё') { 'ё' }
			return self
		end
	end
 
  def to_ary
    ary=[]
    text = self.clone
    while ((c = text.slice!(/./m)) != nil)
      ary+=[c]
    end
    return ary
  end
end
#-------------------------------------------------------------------------------
#                             MODULE RPG
#------------------------------------------------------------------------------- 
module RPG
    def self.warn(message)
    $game_system.se_play($data_system.decision_se)
    Graphics.freeze
    window = Window_Base.new(32, 192, 576, 96)
    window.contents = Bitmap.new(window.width - 32, window.height - 32)
    window.contents.draw_text(0, 0, window.width - 32, 32, message, 1)
    window.contents.draw_text(0, 32, 544, 32, "OK", 1)
    window.cursor_rect.set(208, 32, 128, 32)
    window.active = true
    window.z = 5000
    Graphics.transition
    loop do
      Input.update
      Graphics.update
      window.update
      if Input.trigger?(Input::C) or Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        break
      end
    end
    Graphics.freeze
    window.dispose
    Graphics.transition
    return
  end
 
  def self.confirm(message)
    $game_system.se_play($data_system.buzzer_se)
    Graphics.freeze
    window = Window_Base.new(32, 192, 576, 96)
    window.contents = Bitmap.new(window.width - 32, window.height - 32)
    window.contents.draw_text(0, 0, window.width - 32, 32, message, 1)
    window.contents.draw_text(0, 32, 272, 32, "OK", 1)
    window.contents.draw_text(272, 32, 272, 32, "Cancel", 1)
    window.cursor_rect.set(72, 32, 128, 32)
    window.active = true
    window.z = 5000
    Graphics.transition
    index = 0
    result = nil
    while result.nil?
      Input.update
      Graphics.update
      window.update
      if Input.repeat?(Input::LEFT) or Input.repeat?(Input::RIGHT)
        $game_system.se_play($data_system.cursor_se)
        index += 1
        index %= 2
        window.cursor_rect.set(72 + 272 * index, 32, 128, 32)
      end
      if Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        result = index == 0
      end
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        result = false
      end
    end
    Graphics.freeze
    window.dispose
    Graphics.transition
    return result
  end
end
#-------------------------------------------------------------------------------
#                               BITMAP
#-------------------------------------------------------------------------------
class Bitmap  
  def darken(factor)
    factor = 1 - factor
    for y in 0...self.height
      for x in 0...self.width
        color = self.get_pixel(x, y)
        next if color.alpha == 0
        self.set_pixel(x, y, Color.new(color.red * factor, color.green * factor,
          color.blue * factor, color.alpha) )
      end
    end
    GC.start
  end
 
  def lighten(factor)
    p = 255 * factor
    factor = 1 - factor
    for y in 0...self.height
      for x in 0...self.width
        color = self.get_pixel(x, y)
        next if color.alpha == 0
        self.set_pixel(x, y, Color.new(color.red * factor + p, color.green * factor + p,
          color.blue * factor + p, color.alpha) )
      end
    end
    GC.start
  end
end
#-------------------------------------------------------------------------------
#                               BITMASK
#-------------------------------------------------------------------------------
class Bitmask
  def initialize(size = 1)
    @data = [0]
    resize(size)
  end
 
  def [](i)
    if i >= @size
      raise RangeError, "Bit ##{i} not defined (max = #{@size - 1}) in Bitmask#[]"
    end
    return @data[i >> 5][i & 31] == 1
  end
 
  def []=(i, b)
    case b
    when TrueClass, FalseClass
      if self[i] == b
        return nil
      else
        @data[i >> 5] ^= 2 ** i
        return b
      end
    else
      raise TypeError, "TrueClass or FalseClass expected as parameters in Bitmask#[]="
    end
  end
 
  def resize(size)
    while (size >> 5) >= @data.size
      @data << 0
    end
    @size = size
  end
 
  def to_s
    str = String.new
    for i in 0...@size
      if i & 7 == 0
        str << " "
      end
      str << @data[i >> 5][i & 31].to_s
    end
    return str
  end
end
#-------------------------------------------------------------------------------
#                                SYMBOL
#-------------------------------------------------------------------------------
class Symbol
	# Правильно превращает символ в строку текста
  def display
    str = ""
    name = self.to_s
    name.split("_").each { |s| str += s.capitalize + " " }
    str = str.rstrip
    return str
  end
end
#-------------------------------------------------------------------------------
#                               	DIR
#-------------------------------------------------------------------------------
class Dir
  # Возвращает все файлы, в названии которых имеются заданные значения,
  # в заданном каталоге как массив
  #  - каталог: путь к папке, в которой будет произведен поиск
  # (примеры: "C:\Temp" или "Graphics\Titles")
  #  - фильтр(-ы): значения, по которым нужно искать
  # (примеры: "_blue", "icon", ".png", [".txt",".html"] )
  def self.files(directory = self.pwd, *filters)
    ary = []
    for filename in self.entries(directory)
      next if File.directory?(filename) or filename == "." or filename == ".."
      if filters.empty? or filters.include?(File.extname(filename))
        ary << filename
      end
    end
    return ary
  end
 
  # Возвращает все каталоги, находящиеся в заданном, как массив 
  def self.subdirectories(directory = self.pwd)
    ary = []
    for filename in self.entries(directory)
      if File.directory?(filename)
        ary << filename
      end
    end
    return ary
  end
 
	def self.has_subdirectories?(directory = self.pwd)
		ary = []
		for filename in self.entries(directory)
			if File.directory?(filename)
				ary << filename
			end
		end
		return true if ary.size>0
		return false
	end
end
#-------------------------------------------------------------------------------
#                               	FILE
#-------------------------------------------------------------------------------
class File
	def self.directory?(filename)
		return false if filename == "."
		return true if self.extname(filename) == ""
		return false
	end
end