ТЕМА: RGSS: Работа с файлами и папками; чтение текстового файла.

module RPG
  class DataLoad
    #==========================================================================
    # Кастомные базы данных
    #--------------------------------------------------------------------------
    # Видео
    #--------------------------------------------------------------------------
    # Массив, индекс которого принимается за id видео. Первый элемент - nil.
    # Каждый последующий элемент так же представляет из себя массив:
    # [0 : string]  - Собственное имя видео
    # [1 : string]  - Название папки с набором кадров, каждого кадра, без нумерации
    # [2 : integer] - Номер первого кадра
    # [3 : integer] - Количество знаков в номере кадра
    # [4] : integer - Одномерный массив, указывающий расположение видео [x, y] 
    # [5 : integer] - Оттенок изображения (0..360)
    VIDEO = [nil,
      [ Стартовое видео ,  start , 1, 4, [0, 0], 0],
    ]
    #==========================================================================
    # Метод подгружает кастомную базу данных $data_video
    def video
      $data_video    = []                  # Создаем глобальный массив
      $data_video[0] = nil                 # Первый элемент, традиционно, nil.
      for i in 1..VIDEO.size - 1           # Перебираем элементы массива VIDEO
        $data_video[i] = RPG::Video.new    # Создаем новый объект на основе RPG::Video
        $data_video[i].id = i              # В качестве id берем и записываем индекс в массиве
        $data_video[i].name = VIDEO[i][0] # Записываем имя видео
        # Записываем имя каждого кадра и подсчитываем их количество
        frame_index = VIDEO[i][2]
        path =  Graphics/Video/  + VIDEO[i][1] +  / 
        n = 0
        loop do
          counter = $EKLib.intToString(frame_index, VIDEO[i][3])
          filename = VIDEO[i][1] +  _  + counter
          if FileTest.exist?(path + filename +  .png )
            $data_video[i].frames[n] = path + filename +  .png 
          elsif FileTest.exist?(path + filename +  .jpg )
            $data_video[i].frames[n] = path + filename +  .jpg 
          else
            break
          end
          n += 1
          frame_index += 1
        end
        $data_video[i].frame_max = frame_index - 1 # Записываем количество кадров
        $data_video[i].position = VIDEO[i][4] # Записываем положение видео
        $data_video[i].video_hue = VIDEO[i][5] # Записываем оттенок видео
      end
    end
  end
end

module RPG
  class Video
    def initialize
      @id = 0
      @name =   
      @frames = [  ]
      @frame_max = 1
      @position = [0, 0]
      @video_hue = 0
    end
    attr_accessor :id
    attr_accessor :name
    attr_accessor :frames
    attr_accessor :frame_max
    attr_accessor :position
    attr_accessor :video_hue
  end
end

#==============================================================================
# EK Lib v.1.3b
#------------------------------------------------------------------------------
# Created by: Equilibrium Keeper [[email protected]]
# Created on: 11.07.2008 23:11:45
# Отдельное спасибо: insider, Рольф
#          А так же: rpgmaker.sk6.ru, rpg-maker.info, gdsa.rpgmaker.ru
#==============================================================================
# Описание: Библиотека содержит несколько наиболее часто используемых мной
#           функций. При желании вы можете воспользоваться ими, но делайте
#           это на свой страх и риск.
#------------------------------------------------------------------------------
# Установка: В редакторе скриптов создайте чистую страницу над  Main  и
#            скопируйте туда данный скрипт.
#==============================================================================
class EKLib
 
  # Метод ворвращает фрагмент изображения.
  # filename : string   - имя файла, относительно папки проекта.
  # index    : integer - порядковый номер изображения
  # width    : integer - ширина фрагмента
  # height   : integer - высота фрагмента
  # Примечание: Счет ведется слева направо, сверху вниз.
  def getImagePartByIndex (filename, index, width, height)
    bitmap = Bitmap.new (filename)
    bitmap_result = Bitmap.new (width, height)
    n = bitmap.width / width
    x = (index * width - width) - ((index - 1) / n) * width * n
    y = ((index - 1) / n) * height
    rect = Rect.new(x, y, width, height)
    bitmap_result.blt(0, 0, bitmap, rect)
    return bitmap_result
  end
 
  # Метод преобразует целое число в строку с заданным количеством знаков.
  # number         : integer - число, которое требуется преобразовать
  # digits         : integer - количество знаков в возвращаемой строке
  # filling_symbol : string   - символ, заполняющий не достающие знаки
  def intToString (number, digits = 3, filling_symbol =  0 )
    i = number
    counter = number.to_s
    for i in number.to_s.size..digits - 1
      counter = filling_symbol + counter
      i += 1
    end
    return counter
  end
 
  # Метод построчно рисует заданный text на bitmap, перенося непомещающиеся слова
  # text         : string   - строка (длина не важна), которую требуется записать
  # bitmap       : bitmap   - изображение, на котором будем рисовать
  # width        : integer - максимальная надписи строк
  # x            : integer - Координата x начала первой строки
  # y            : integer - Координата y начала первой строки
  # stringheight : integer - Высота строки; -1 - высота будет высчитана автоматически
  # correct      : integer - Коректеровка длины строки (количество байт); +/-
  # fontsize     : integer - Размер шрифта. Используется только для вычеслений.
  def hyphenDrawText (text, bitmap, width, x = 20, y = 20, stringheight = -1, correct = 0, fontsize = bitmap.font.size)
    n = 0
    index = 0
    strings = []
    # Если высота строки не была задана, высчитываем ее исходя из размера шрифта
    if stringheight == -1 then stringheight = 24 - 0.2 * (24 - fontsize) end
    # Высчитываем примерное количество знаков на строку исходя из размера шрифта
    if fontsize   24 then const = 2 else const = 6 end
    maxchar = width / fontsize * 5 - (24 - fontsize) * const + correct
    maxchar = maxchar / 2 * 2
    # Делим строку на несколько
    while n   text.size
      # Записываем в массив фрагмент строки начиная с n байта длиной maxchar байт
      strings[index] = text[n, maxchar]
      lenght = maxchar # Временная переменная для переноса слов
      # Пока на конце строки не окажется пробела или она не закончится...
      while strings[index][lenght - 1, 1] !=     && strings[index][lenght - 1, 1] !=   
        # ...урезаем строку на один байт
        lenght -= 1
        strings[index] = strings[index][0, lenght]
      end
      n += lenght - 1 # Задаем новый начальный байт для следующей строки
      index += 1 # Переходим к следующему элементу массива
    end
    for i in 0..strings.size - 1
      # Отрезаем пробелы в начале строки
      if strings[i][0, 1] ==     then strings[i] = strings[i][1, strings[i].size] end
      # Записываем все получившиеся строки на понравившийся bitmap
      bitmap.draw_text(x, y + stringheight * i, width, stringheight, strings[i])
    end
  end
 
  # Метод рисует геометрические фигуры на заданном изображении
  # bitmap : bitmap - изображение, на котором будем рисовать
  # type   : string - тип фигуры, которую будем рисовать
  # color  : color  - цвет, который будем использовать, к примеру Color.new(255,255,255,255)
  # Прочие параметры изменяются от фигуры к фигуре - смотрим скрипт
  # Доступные типы фигур: square =  квадрат;
  def drawFigure (bitmap, type, color, param1 = 0, param2 = 0, param3 = 0, param4 = 0, param5 = 0, param6 = 0)
    case type
    when  square 
      filling = param1 # : Integral [0, 1] Будем ли заливать квадрат или оставим его пустым
      gauge   = param2 # : Integral Толщина линии, в случае заливки принципиального значения не имеет
      x       = param3 # : Integral Координата x верхнего левого угла квадрата
      y       = param4 # : Integral Координата y верхнего левого угла квадрата
      width   = param5 # : Integral Ширина квадрата
      height  = param6 # : Integral Высота квадрата
      if filling != 0
        bitmap.fill_rect(x, y, width, height, color)
      else
        bitmap.fill_rect(x, y, width, gauge, color)
        bitmap.fill_rect(x, y, gauge, height, color)
        bitmap.fill_rect(x, y + height - gauge, width, gauge, color)
        bitmap.fill_rect(x + width - gauge, y, gauge, height, color)
      end
    end
  end
 
end

$EKLib    = EKLib.new
$DataLoad = RPG::DataLoad.new

$DataLoad.video