Foros de Emudesc

#===============================================================
# ● [VX] ◦ MiniMap ◦ □
# * Plug N Play Minimap (Don't need image~) *
#--------------------------------------------------------------
# ◦ by Woratana [woratana@hotmail.com]
# ◦ Thaiware RPG Maker Community
# ◦ Released on: 09/06/2008
# ◦ Version: 1.0 Beta
#--------------------------------------------------------------
# ◦ Credit: KGC for XP MiniMap Script,
# this script can't be done without his MiniMap.
#--------------------------------------------------------------

module MiniMap
  #===========================================================================
  # [START] MINIMAP SCRIPT SETUP PART
  #---------------------------------------------------------------------------
  SWITCH_NO_MINIMAP = 0 # Turn ON this switch to NOT SHOW minimap
    
  MAP_RECT = [410, 20, 100, 100] # Minimap size and position
  # [X, Y, Width, Height]
  # You can change it in game, by call script:
  # $game_system.minimap = [X, Y, Width, Height]

  MAP_Z = 0 # Minimap's Z-coordinate
  # Increase this number if there is problem that minimap show below some objects.

  GRID_SIZE = 5 # Minimap's grid size. Recommend to use more than 3.
  
  MINIMAP_BORDER_COLOR = Color.new(0, 0, 255, 160) # Minimap's border color
  # Color.new(Red, Green, Blue, Opacity)
  MINIMAP_BORDER_SIZE = 2 # Minimap's border size
  
  FOREGROUND_COLOR = Color.new(224, 224, 255, 160) # Passable tile color
  BACKGROUND_COLOR = Color.new(0, 0, 0, 160) # Unpassable tile color

  USE_OUTLINE_PLAYER = true # Draw outline around player in minimap?
  PLAYER_OUTLINE_COLOR = Color.new(0, 0, 0, 192) # Player Outline color
  USE_OUTLINE_EVENT = true # Draw outline around events in minimap?
  EVENT_OUTLINE_COLOR = Color.new(255, 255, 255, 192) # Player Outline color
  
  PLAYER_COLOR = Color.new(255, 0, 0, 192) # Player color
  #---------------------------------------------------------------------------

  OBJECT_COLOR = {} # Don't change or delete this line!
  #===============================================================
  # * SETUP EVENT KEYWORD & COLOR
  #---------------------------------------------------------------
  # ** Template:
  # OBJECT_COLOR['keyword'] = Color.new(Red, Green, Blue, Opacity)
  #-------------------------------------------------------------
  # * 'keyword': Word you want to put in event's comment to show this color
  # ** Note: 'keyword' is CASE SENSITIVE!
  # * Color.new(...): Color you want
  # You can put between 0 - 255 in each argument (Red, Green, Blue, Opacity)
  #-------------------------------------------------------------
  OBJECT_COLOR['npc'] = Color.new(30,144,255,160)
  OBJECT_COLOR['treasure'] = Color.new(0,255,255,160)
  OBJECT_COLOR['enemy'] = Color.new(139,35,35,160)
  OBJECT_COLOR['merchant'] = Color.new(255,255,0,160)
  
  #===========================================================================
  # * [OPTIONAL] TAGS:
  #---------------------------------------------------------------------------
  # Change keyword for disable minimap & keyword for show event on minimap~
  #-----------------------------------------------------------------------
  TAG_NO_MINIMAP = '[NOMAP]'
  TAG_EVENT = 'MMEV'
  #---------------------------------------------------------------------------

  #---------------------------------------------------------------------------
  # [END] MINIMAP SCRIPT SETUP PART
  #===========================================================================
  
  def self.refresh
    if $scene.is_a?(Scene_Map)
      $scene.spriteset.minimap.refresh
    end
  end
  
  def self.update_object
    if $scene.is_a?(Scene_Map)
      $scene.spriteset.minimap.update_object_list
    end
  end
end

#==============================================================================
# ■ RPG::MapInfo
#==============================================================================
class RPG::MapInfo
  def name
    return @name.gsub(/\[.*\]/) { }
  end

  def original_name
    return @name
  end

  def show_minimap?
    return !@name.include?(MiniMap::TAG_NO_MINIMAP)
  end
end
#==============================================================================
# ■ Game_System
#==============================================================================
class Game_System
  attr_accessor :minimap
  alias wora_minimap_gamsys_ini initialize
  
  def initialize
    wora_minimap_gamsys_ini
    @minimap = MiniMap::MAP_RECT
  end
  
  def show_minimap
    return !$game_switches[MiniMap::SWITCH_NO_MINIMAP]
  end
end
#==============================================================================
# ■ Game_Map
#==============================================================================
class Game_Map
  alias wora_minimap_gammap_setup setup
  def setup(map_id)
    wora_minimap_gammap_setup(map_id)
    @db_info = load_data('Data/MapInfos.rvdata') if @db_info.nil?
    @map_info = @db_info[map_id]
  end
  
  def show_minimap?
    return @map_info.show_minimap?
  end
end
#==============================================================================
# ■ Game_Event
#==============================================================================
class Game_Event < Game_Character
  def mm_comment?(comment, return_comment = false )
    if !@list.nil?
      for i in 0...@list.size - 1
        next if @list[i].code != 108
        if @list[i].parameters[0].include?(comment)
          return @list[i].parameters[0] if return_comment
          return true
        end
      end
    end
    return '' if return_comment
    return false
  end
end
#==============================================================================
# ■ Game_MiniMap
#------------------------------------------------------------------------------
class Game_MiniMap
  def initialize(tilemap)
    @tilemap = tilemap
    refresh
  end

  def dispose
    @border.bitmap.dispose
    @border.dispose
    @map_sprite.bitmap.dispose
    @map_sprite.dispose
    @object_sprite.bitmap.dispose
    @object_sprite.dispose
    @position_sprite.bitmap.dispose
    @position_sprite.dispose
  end

  def visible
    return @map_sprite.visible
  end

  def visible=(value)
    @map_sprite.visible = value
    @object_sprite.visible = value
    @position_sprite.visible = value
    @border.visible = value
  end

  def refresh
    @mmr = $game_system.minimap
    map_rect = Rect.new(@mmr[0], @mmr[1], @mmr[2], @mmr[3])
    grid_size = [MiniMap::GRID_SIZE, 1].max

    @x = 0
    @y = 0
    @size = [map_rect.width / grid_size, map_rect.height / grid_size]

    @border = Sprite.new
    @border.x = map_rect.x - MiniMap::MINIMAP_BORDER_SIZE
    @border.y = map_rect.y - MiniMap::MINIMAP_BORDER_SIZE
    b_width = map_rect.width + (MiniMap::MINIMAP_BORDER_SIZE * 2)
    b_height = map_rect.height + (MiniMap::MINIMAP_BORDER_SIZE * 2)
    @border.bitmap = Bitmap.new(b_width, b_height)
    @border.bitmap.fill_rect(@border.bitmap.rect, MiniMap::MINIMAP_BORDER_COLOR)
    @border.bitmap.clear_rect(MiniMap::MINIMAP_BORDER_SIZE, MiniMap::MINIMAP_BORDER_SIZE,
    @border.bitmap.width - (MiniMap::MINIMAP_BORDER_SIZE * 2),
    @border.bitmap.height - (MiniMap::MINIMAP_BORDER_SIZE * 2))
    
    @map_sprite = Sprite.new
    @map_sprite.x = map_rect.x
    @map_sprite.y = map_rect.y
    @map_sprite.z = MiniMap::MAP_Z
    bitmap_width = $game_map.width * grid_size + map_rect.width
    bitmap_height = $game_map.height * grid_size + map_rect.height
    @map_sprite.bitmap = Bitmap.new(bitmap_width, bitmap_height)
    @map_sprite.src_rect = map_rect

    @object_sprite = Sprite.new
    @object_sprite.x = map_rect.x
    @object_sprite.y = map_rect.y
    @object_sprite.z = MiniMap::MAP_Z + 1
    @object_sprite.bitmap = Bitmap.new(bitmap_width, bitmap_height)
    @object_sprite.src_rect = map_rect

    @position_sprite = Sprite_Base.new
    @position_sprite.x = map_rect.x + @size[0] / 2 * grid_size
    @position_sprite.y = map_rect.y + @size[1] / 2 * grid_size
    @position_sprite.z = MiniMap::MAP_Z + 2
    
    bitmap = Bitmap.new(grid_size, grid_size)
    # Player's Outline
    if MiniMap::USE_OUTLINE_PLAYER and MiniMap::GRID_SIZE >= 3
      bitmap.fill_rect(bitmap.rect, MiniMap::PLAYER_OUTLINE_COLOR)
      brect = Rect.new(bitmap.rect.x + 1, bitmap.rect.y + 1, bitmap.rect.width - 2,
        bitmap.rect.height - 2)
      bitmap.clear_rect(brect)
    else
      brect = bitmap.rect
    end
    
    bitmap.fill_rect(brect, MiniMap::PLAYER_COLOR)
    @position_sprite.bitmap = bitmap

    draw_map
    update_object_list
    draw_object
    update_position
  end

  def draw_map
    bitmap = @map_sprite.bitmap
    bitmap.fill_rect(bitmap.rect, MiniMap::BACKGROUND_COLOR)
    map_rect = Rect.new(@mmr[0], @mmr[1], @mmr[2], @mmr[3])
    grid_size = [MiniMap::GRID_SIZE, 1].max
    
    $game_map.width.times do |i|
      $game_map.height.times do |j|
        if !$game_map.passable?(i, j)
          next
        end
        rect = Rect.new(map_rect.width / 2 + grid_size * i,
          map_rect.height / 2 + grid_size * j,
          grid_size, grid_size)
        if grid_size >= 3
          if !$game_map.passable?(i, j)
            rect.height -= 1
            rect.x += 1
            rect.width -= 1
            rect.width -= 1
            rect.y += 1
            rect.height -= 1
          end
        end
        bitmap.fill_rect(rect, MiniMap::FOREGROUND_COLOR)
      end
    end
  end

  def update_object_list
    @object_list = {}
    $game_map.events.values.each do |e|
      comment = e.mm_comment?(MiniMap::TAG_EVENT, true)
      if comment != ''
        type = comment.gsub(/#{MiniMap::TAG_EVENT}/){}.gsub(/\s+/){}
        @object_list[type] = [] if @object_list[type].nil?
        @object_list[type] << e
      end
    end
  end

  def draw_object
    bitmap = @object_sprite.bitmap
    bitmap.clear
    map_rect = Rect.new(@mmr[0], @mmr[1], @mmr[2], @mmr[3])
    grid_size = [MiniMap::GRID_SIZE, 1].max
    rect = Rect.new(0, 0, grid_size, grid_size)
    mw = map_rect.width / 2
    mh = map_rect.height / 2

    @object_list.each do |key, events|
      color = MiniMap::OBJECT_COLOR[key]
      next if events.nil? or color.nil?
      events.each do |obj|
        if !obj.character_name.empty?
          rect.x = mw + obj.real_x * grid_size / 256
          rect.y = mh + obj.real_y * grid_size / 256
          # Event's Outline
          if MiniMap::USE_OUTLINE_EVENT and MiniMap::GRID_SIZE >= 3
            bitmap.fill_rect(rect, MiniMap::EVENT_OUTLINE_COLOR)
            brect = Rect.new(rect.x + 1, rect.y + 1, rect.width - 2,
            rect.height - 2)
            bitmap.clear_rect(brect)
          else
            brect = bitmap.rect
          end
          bitmap.fill_rect(brect, color)
        end
      end
    end
  end

  def update
    if @mmr != $game_system.minimap
      dispose
      refresh 
    end
    draw_object
    update_position
    if @map_sprite.visible
      @map_sprite.update
      @object_sprite.update
      @position_sprite.update
    end
  end

  def update_position
    map_rect = Rect.new(@mmr[0], @mmr[1], @mmr[2], @mmr[3])
    grid_size = [MiniMap::GRID_SIZE, 1].max
    sx = $game_player.real_x * grid_size / 256
    sy = $game_player.real_y * grid_size / 256
    @map_sprite.src_rect.x = sx
    @map_sprite.src_rect.y = sy
    @object_sprite.src_rect.x = sx
    @object_sprite.src_rect.y = sy
  end
end
#==============================================================================
# ■ Spriteset_Map
#------------------------------------------------------------------------------
class Spriteset_Map
  attr_reader :minimap
  alias wora_minimap_sprsetmap_ini initialize
  alias wora_minimap_sprsetmap_dis dispose
  alias wora_minimap_sprsetmap_upd update
  
  def initialize
    wora_minimap_sprsetmap_ini
    if $game_map.show_minimap?
      @minimap = Game_MiniMap.new(@tilemap)
      $game_system.show_minimap = true if $game_system.show_minimap.nil?
      @minimap.visible = $game_system.show_minimap
    end
  end
  
  def dispose
    @minimap.dispose if !@minimap.nil?
    wora_minimap_sprsetmap_dis
  end

  def update
    if !@minimap.nil?
      if $game_system.show_minimap
        @minimap.visible = true
        @minimap.update
      else
        @minimap.visible = false
      end
    end
    wora_minimap_sprsetmap_upd
  end
end
#==============================================================================
# ■ Scene_Map
#------------------------------------------------------------------------------
class Scene_Map < Scene_Base
  attr_reader :spriteset
end

#
# Sistema de Tempo Kylock para VX v1.3
#	 10.5.2008
# traduzido pela Equipe Gemstone
#
#  Script por: Kylock
#            Praticamente todo reescrito desde a versão para XP. Códigos mais limpos
# e compatíveis. Esse é o meu sistema de dia e noite. Ele adiciona uma nova janela
# ao menu, então, se você usa um CMS, cole este script acima dele.
#            Eu tentei fazer esse o mais customizável possível, as configurações
# são encontrada logo em baixo. Embora as variáveis sejam opcionais, eu
# sugiro que as usem, pois poderão construtir eventos baseados nesse script
# mais facilmente.
#
# Histórico
#  1.0 - Lançamento.
#  1.1 - Corrigido a mudança de tonalidade nas batalhas.  Coloque este script
#		abaixo de scripts de batalha caso você note alguma erro na mesma.
#  1.2 - Corrigida a precisão de $kts.stop e $kts.go
#  1.3 - $kts.stop realmente para tudo agora.  Adicionadas switches para eventos.
#
# Instruções de Mudança de Tonalidade
#
#            Mapas designados como "fora" são os únicos que devem ser afetados pela
# tonalidade. Coloque um [KTS] antes do nome do mapa para criar este efeito.
#
# Chamar Funções do Script
#
#            Use o comando "Chamar Script".
#	$kts.stop			- parar o tempo
#	$kts.go			  - continuar o tempo
#	$kts.sec(n)		  - avança (n) segundos
#	$kts.min(n)		  - avança (n) minutos
#	$kts.hours(n)		- avança (n) horas
#	$kts.days(n)		 - avança (n) dias.
#	$kts.jump_to_hour(n) - Muda o tempo para a hora (n).
#
# Configurações do Dabatase do Jogo
#
#	Esse script, por padrão, usa as seguintes variáveis e switches:
#  Variáveis:
#	[1] O tempio atual              	  [4] Horas Atual
#	[2] Segundo atual		  [5] Dia Atual
#	[3] Minuto atual 		  [6] Nome do dia atual
#  Switches:
#	[23] ON durante a noite  		(2200-0400)(10pm-4am)
#	[24] ON durante a madrugada		(0500-0800)( 5am-8am)
#	[25] ON durante o amanhecer		(0900-1800)( 9am-6pm)
#	[26] ON durante o anoitecer		(1900-2100)( 7pm-9pm)
#
#

# Guarda as configurações definidas.
#
module KTS
  #-
  # Define as configurações do relógio
  #-
  # Define a velocidade do relógio.
  #   1 é o tempo real. O padrão é 100 (cem vezes mais rápido do que o tempo real)
  SPEED	  = 100
  #AM-PM? (True: relógio de 12 horas AM e 12 horas PM, False: relógio de 24 horas)
  AMPM	   = false
  # Define o horário inicial do jogo.
  START_HOUR = 13
  START_DAY  = 5
  #-
  # Nomes dos dias
  #-
  DAY_NAMES = ["Domingo","Lunes","Martes","Miercoles","Jueves","Viernes","Sábado"]
  #-
  # Períodos
  #-
  T1 = [ 0,5 ] # Noite		 # Arruma os períodos para a tonalidade.
  T2 = [ 6,8 ] # Madrugada		  # [Hora Inicial, Hora Final]
  T3 = [ 9,18] # Manhã		   # Use termos de um relógio de 24 horas.
  T4 = [19,21] # Tarde
  T5 = [22,24] # Noite		 # <- Ex: Noite é entre 22:00 e 24:00
  #-
  # Configurações para as variáveis em jogo
  #-
  # True para colocar o tempo nas variáveis e switches definidas
  DATABASE_OUTPUT = false
	# Variável a ser usada
	TIME	= 1 #(É nesse formato: "2:48 AM" ou "02:48")
	SECONDS = 2 
	MINUTES = 3 
	HOURS   = 4 
	DAYS	= 5 
	DAYNAME = 6
	# Switches
	NIGHT   = 23 #    Estará on nas horas definidas
	DAWN	= 24 #  Estará on nas horas definidas
	DAY	 = 25 # Estará on nas horas definidas
	SUNSET  = 26 #   Estará on nas horas definidas
  #-
  # Configurações para a tonalidade da tela
  #-
  # True para habilitar essa função; false para desabilitar essa função.
  USE_TONE = true
  # Duração da mudança de tonalidade (em frames)
  FADE_LENGTH = 120
  # Definir Tonalidades para cada período
  #			  Vermelho, Verde, Azul, Cinza
  C1 = Tone.new(-187,  -119,  -17,  68)
  C2 = Tone.new(  17,   -51, -102,   0)
  C3 = Tone.new(   0,	 0,	0,   0)
  C4 = Tone.new( -68,  -136,  -34,   0)
  C5 = Tone.new(-187,  -119,  -17,  68)
end

#
# Engine do Sistema de Tempo
#
class Kylock_Time_System
  # arrumas as variáveis
  def initialize
	$kts_map_data = load_data("Data/MapInfos.rvdata")
	@event_offset = (KTS::START_HOUR * 3600) + (KTS::START_DAY * 86400)
	@kts_stop = false
	$kts_event_tone = false
	$kts_battle_tone = true
  end
  
  # Guarda o tempo e atualiza
  def update
	if !@kts_stop
	  @total_seconds = (Graphics.frame_count * KTS::SPEED / 60) + @event_offset
	  @seconds = (@total_seconds) % 60
	  @minutes = (@total_seconds / 60) % 60
	  @hours   = (@total_seconds / 3600) % 24
	  @days	= (@total_seconds / 86400)
	  update_tint
	  if KTS::DATABASE_OUTPUT
		update_variables
		update_switches
	  end
	end
  end

  def update_variables
	$game_variables[KTS::TIME]	= getTime
	$game_variables[KTS::SECONDS] = @seconds
	$game_variables[KTS::MINUTES] = @minutes
	$game_variables[KTS::HOURS]   = @hours
	$game_variables[KTS::DAYS]	= @days
	$game_variables[KTS::DAYNAME] = getDayName
  end

  def update_switches
	if @period == 1 || @period == 5
	  $game_switches[KTS::NIGHT] = true
	else
	  $game_switches[KTS::NIGHT] = false
	end
	if @period == 2
	  $game_switches[KTS::DAWN] = true
	else
	  $game_switches[KTS::DAWN] = false
	end
	if @period == 3
	  $game_switches[KTS::DAY] = true
	else
	  $game_switches[KTS::DAY] = false
	end
	if @period == 4
	  $game_switches[KTS::SUNSET] = true
	else
	  $game_switches[KTS::SUNSET] = false
	end
  end

  def getTime
	if KTS::AMPM
	  # Formats a 12-Hour Clock
	  if @hours > 12
		hours1 = @hours - 12
		if hours1 > 9
		  time = sprintf("%02d:%02d" + " PM", hours1, @minutes)
		else
		  time = sprintf("%01d:%02d" + " PM", hours1, @minutes)
		end
	  else
		if @hours > 9
		  time = sprintf("%02d:%02d" + " AM", @hours, @minutes)
		else
		  time = sprintf("%01d:%02d" + " AM", @hours, @minutes)
		end
	  end
	  return time
	else
	  # Formats a 24-Hour Clock
	  time = sprintf("%02d:%02d", @hours, @minutes)
	  return time
	end
  end
  #-
  # Comandos para as Funções do Script
  #-
  def stop
	@time_stopped = @total_seconds
	@kts_stop = true
  end
  def go
	total_seconds = (Graphics.frame_count * KTS::SPEED / 60) + @event_offset
	@event_offset -= (total_seconds - @time_stopped)
	@kts_stop = false
  end
  def sec(sec = 0)
	@event_offset += sec
  end
  def min(min = 0)
	@event_offset += min * 60
  end
  def hours(hours = 0)
	@event_offset += hours * 3600
  end
  def days(days = 0)
	@event_offset += days * 86400
  end
  def jump_to_hour(jhour = 0)
	while @hours != jhour
	  @event_offset += 1
	  $kts.update
	end
  end
  #-
  # Outras funções
  #-
  def getDayName
	weekday = (@days % KTS::DAY_NAMES.length)
	return KTS::DAY_NAMES[weekday]
  end

  #-
  # Tonalidade de Tela
  #-
  def update_tint(duration = KTS::FADE_LENGTH)
	if KTS::USE_TONE && !$kts_event_tone && $kts_map_data[$game_map.map_id].outside_tint?
	  if @hours >= KTS::T1[0] and @hours <= KTS::T1[1]
		@period = 1
		screen.start_tone_change(KTS::C1,duration)
	  elsif @hours >= KTS::T2[0] and @hours <= KTS::T2[1]
		@period = 2
		screen.start_tone_change(KTS::C2,duration)
	  elsif @hours >= KTS::T3[0] and @hours <= KTS::T3[1]
		@period = 3
		screen.start_tone_change(KTS::C3,duration)
	  elsif @hours >= KTS::T4[0] and @hours <= KTS::T4[1]
		@period = 4
		screen.start_tone_change(KTS::C4,duration)
	  elsif @hours >= KTS::T5[0] and @hours <= KTS::T5[1]
		@period = 5
		screen.start_tone_change(KTS::C5,duration)
	  end
	else
	  # sem mundaça nos mapas "dentro"
	  if !$kts_map_data[$game_map.map_id].outside_tint?
		screen.start_tone_change(Tone.new(0,0,0,0),duration)
	  end
	end
  end
  def screen
	if $game_temp.in_battle
	  return $game_troop.screen
	else
	  return $game_map.screen
	end
  end
end

#
# Atualiza instantaneamente quando se teletransporta
#
class Game_Map
  alias kts_setup setup
  def setup(map_id)
	kts_setup(map_id)
	$kts_event_tone = false
	$kts.update
	$kts.update_tint(0)
  end
end

#
# Atualiza instantaneamente quando entra na batalha
#
class Spriteset_Battle
  alias kts_create_battleback create_battleback
  def create_battleback
	$kts.update_tint(0)
	kts_create_battleback
  end
end

#
# Desabilita temporariamente quando um evento muda a tonalidade
#
class Game_Interpreter
  alias kts_Interpreter_command_223 command_223
  def command_223
	$kts_event_tone = true
	kts_Interpreter_command_223
  end
end

#
# Integra o sistema ao Game System
#
class Game_System
  # inits a KTS object
  alias kts_initialize initialize
  def initialize
	$kts=Kylock_Time_System.new
	kts_initialize
  end
  # Updates kts every game frame
  alias kts_update update
  def update
	$kts.update
	kts_update
  end
end

#
# Scaneia mapas para o nome
#
class RPG::MapInfo
  def name # Impede que sistemas de localização leiam o [KTS]
	return @name.gsub(/\[.*\]/) {""} # colchetes e os inclusos
  end
  def original_name
	return @name
  end
  def outside_tint?
	return @name.scan(/[\KTS]/).size > 0
  end
end

#
# Configura a janela de tempo
#
class Window_KTS < Window_Base
  def initialize(x, y)
	super(x, y, 160, WLH + 32)
	refresh
  end
  def refresh
	self.contents.clear
	self.contents.draw_text(4, -6, 120, 32, $kts.getTime, 2)
  end
  def update
	super
	$kts.update
	self.contents.clear
	self.contents.draw_text(4, -6, 120, 32, $kts.getTime, 2)
  end
end

#
# Adiciona a janela ao menu
#
class Scene_Menu < Scene_Base
  alias kts_start start
  def start
	kts_start
	@kts_window = Window_KTS.new(0,305)
  end
  alias kts_terminate terminate
  def terminate
	kts_terminate
	@kts_window.dispose
  end
  alias kts_update update
  def update
	kts_update
	@kts_window.update
  end
end

#
# Para as tela de Load/Save
#
class Scene_File
  alias kts_write_save_data write_save_data
  def write_save_data(file)
	kts_write_save_data(file)
	Marshal.dump($kts, file)
  end
  alias kts_read_save_data read_save_data
  def read_save_data(file)
	kts_read_save_data(file)
	$kts = Marshal.load(file)
  end
end