Script di compatibilitÓ(VX a XP)

Descrizione

Questo script permette di far leggere al vx molti script x xp e poterli utilizzare sull'vx!

Istruzioni per l'uso

Inserire sopra Main gli script in rgss vanno inseriti sotto a questo, diversamente da quelli in rgss2

CODICE
==========================================================================
# Script di compatibilitÓ (VX a XP)
#==========================================================================
# Creato da sandgolem & Solstice
# Versioneo 3 [VX]
# Modificato da Rinnegatamante
#==========================================================================

module GameBaker
  BattleCompatibilityType = 2
end


$DEBUG = $TEST

module Cache
  def self.battleback(filename); Cache.system(filename); end
  def self.fog(filename); Cache.system(filename); end
  def self.gameover(filename); Cache.system(filename); end
  def self.icon(filename); Cache.system(filename); end
  def self.panorama(filename); Cache.parallax(filename); end
end

module RPG
  class Armor
    def guard_element_set; return @element_set; end
  end
    
  class System
    def cursor_se; return @sounds[0]; end
    def decision_se; return @sounds[1]; end
    def cancel_se; return @sounds[2]; end
    def buzzer_se; return @sounds[3]; end
    def equip_se; return @sounds[4]; end
    def shop_se; return @sounds[17]; end
    def save_se; return @sounds[5]; end
    def load_se; return @sounds[6]; end
    def battle_start_se; return @sounds[7]; end
    def escape_se; return @sounds[8]; end
    def enemy_collapse_se; return @sounds[11]; end
    def actor_collapse_se; return @sounds[13]; end
    def windowskin_name; return 'Window'; end
  end
end

class Game_Actor
  def equip(type,id,test = false); change_equip_by_id(type,id,test); end
end
  
class Game_Battler
  attr_accessor :animation_hit, :critical, :damage, :damage_pop
  
  def current_action; return @action; end
  def sp; return @mp; end
  def sp=(num); mp = num; end
end
  
class Game_Character
  attr_accessor :character_hue
end

class Game_Interpreter
  def command_106; command_230; end
  def command_207; command_212; end
  def command_208; command_211; end
  def command_209; command_205; end
end

class Game_Map
  attr_accessor :autotile_names, :battleback_name, :priorities, :tileset_name
  attr_accessor :fog_blend_type, :fog_hue, :fog_opacity, :fog_ox, :fog_oy,
                :fog_name, :fog_sx, :fog_sy, :fog_tone, :fog_zoom
  attr_accessor :panorama_hue, :terrain_tags
  
  def panorama_name; return parallax_name; end
  def panorama_name=(num); @parallax_name = num; end
end

class Game_Party
  def actors; members; end
  def gain_armor(id,num); gain_item($data_armors[id],num); end
  def gain_weapon(id,num); gain_item($data_weapons[id],num); end

  def gain_item(id,num,something = false)
    id = $data_items[id] if id.is_a?(Integer)
    gain_item(id,num,something)
  end
end

class Game_Player
  attr_accessor :transferring, :new_map_id, :new_x, :new_y, :new_direction
end

class Game_System
  attr_accessor :magic_number, :message_frame
  
  def battle_interpreter; return $game_troop.interpreter; end
  def bgm_play(name); gamebaker_compatibility_sound(name,'RPG::BGM'); end
  def bgs_play(name); gamebaker_compatibility_sound(name,'RPG::BGS',80); end
  def map_interpreter; return $game_map.interpreter; end
  def me_play(name); gamebaker_compatibility_sound(name,'RPG::ME'); end
  def message_position; return $game_message.position; end
  def message_position=(num); $game_message.position = num; end
  def se_play(name); gamebaker_compatibility_sound(name,'RPG::SE',80); end
  
  def gamebaker_compatibility_sound(name,type,vol = 100)
    begin
      name.play
    rescue
      pitch = 100
      if name.is_a?(RPG::AudioFile)
        vol = name.volume
        pitch = name.pitch
        name = name.name
      end
      temp = eval(type + '.new(name,' + vol.to_s + ',' + pitch.to_s + ')')
      temp.play
    end
  end
end

class Game_Temp
  attr_accessor :gamebaker_compat_gameover2, :battle_main_phase,
    :transition_name, :transition_processing, :battleback_name
  
  def gameover; return @gamebaker_compat_gameover2; end
  def gameover=(num)
    if num == true
      if @in_battle
        $scene.call_gameover
      else
        @next_scene = 'gameover'
      end
      return
    end
    @gamebaker_compat_gameover2 = nil
    @next_scene = nil if @next_scene == 'gameover'
  end

  def gamebaker_compat_scenecall(num,name)
    if num == true
      @next_scene = name
    elsif @next_scene == name
      @next_scene = nil
    end
  end
  
  def battle_calling; return @next_scene == 'battle'; end
  def battle_calling=(num); gamebaker_compat_scenecall(num,'battle'); end
  def debug_calling; return @next_scene == 'debug'; end
  def debug_calling=(num); gamebaker_compat_scenecall(num,'debug'); end
  def menu_calling; return @next_scene == 'menu'; end
  def menu_calling=(num); gamebaker_compat_scenecall(num,'menu'); end
  def name_calling; return @next_scene == 'name'; end
  def name_calling=(num); gamebaker_compat_scenecall(num,'name'); end
  def save_calling; return @next_scene == 'save'; end
  def save_calling=(num); gamebaker_compat_scenecall(num,'save'); end
  def shop_calling; return @next_scene == 'shop'; end
  def shop_calling=(num); gamebaker_compat_scenecall(num,'shop'); end
  def to_title; return @next_scene == 'title'; end
  def to_title=(num); gamebaker_compat_scenecall(num,'title'); end

  def battle_abort; return @next_scene == 'map'; end
  def battle_abort=(num); $game_temp.next_scene = "map" if num == true; end
  def battle_can_escape; return $game_troop.can_escape; end
  def battle_can_escape=(num); $game_troop.can_escape = num; end
  def battle_can_lose; return $game_troop.can_lose; end
  def battle_can_lose=(num); $game_troop.can_lose = num; end
  def battle_event_flags; return $game_troop.event_flags; end
  def battle_event_flags=(num); $game_troop.event_flags = num; end
  def battle_forcing_battler; return $game_troop.forcing_battler; end
  def battle_forcing_battler=(num); $game_troop.forcing_battler = num; end  
  def battle_troop_id; return $game_troop.troop_id; end
  def battle_troop_id=(num); $game_troop.gamebaker_compat_id = num; end
  def battle_turn; return $game_troop.turn_count; end
  def battle_turn=(num); $game_troop.turn_count = num; end
  
  def choice_cancel_type; return $game_message.choice_cancel_type; end
  def choice_cancel_type=(num); $game_message.choice_cancel_type = num; end
  def choice_max; return $game_message.choice_max; end
  def choice_max=(num); $game_message.choice_max = num; end
  def choice_proc; return $game_message.choice_proc; end
  def choice_proc=(num); $game_message.choice_proc = num; end
  def choice_start; return $game_message.choice_start; end
  def choice_start=(num); $game_message.choice_start = num; end
  def message_proc; return $game_message.main_proc; end
  def message_proc=(num); $game_message.main_proc = num; end
  def message_text; return $game_message.texts.to_s; end
  def message_text=(num); $game_message.texts = num.to_a; end
  def message_window_showing; return $game_message.visible; end
  def message_window_showing=(num); $game_message.visible = num; end
  def num_input_digits_max; return $game_message.num_input_digits_max; end
  def num_input_digits_max=(num); $game_message.num_input_digits_max = num; end
  def num_input_variable_id; return $game_message.num_input_variable_id; end
  def num_input_variable_id=(num); $game_message.num_input_variable_id = num; end
    
  def player_new_direction; return $game_player.new_direction; end
  def player_new_direction=(num); $game_player.new_direction = num; end
  def player_new_map_id; return $game_player.new_map_id; end
  def player_new_map_id=(num); $game_player.new_map_id = num; end
  def player_new_x; return $game_player.new_x; end
  def player_new_x=(num); $game_player.new_x = num; end
  def player_new_y; return $game_player.new_y; end
  def player_new_y=(num); $game_player.new_y = num; end
  def player_transferring; return $game_player.transferring; end
  def player_transferring=(num); $game_player.transferring = num; end
end

class Game_Troop
  attr_accessor :event_flags, :gamebaker_compat_id, :troop_id, :turn_count
  
  alias_method :gamebaker_compatibility_setup, :setup
  def setup(troop_id)
    if @gamebaker_compat_id
      troop_id = @gamebaker_compat_id
      @gamebaker_compat_id = nil
    end
    gamebaker_compatibility_setup(troop_id)
  end
end

class Scene_Battle
  alias_method :gamebaker_compatibility_gameoverjudge, :judge_win_loss
  def judge_win_loss
    if $game_temp.in_battle && $game_party.all_dead?
      $game_temp.gamebaker_compat_gameover2 = true
    else
      $game_temp.gamebaker_compat_gameover2 = nil
    end
    return gamebaker_compatibility_gameoverjudge
  end
  
  
  def update_phase4_step3; end
  def update_phase4_step4; end
  def update_phase4_step5; end
    
  alias_method :gamebaker_compatibility_dispaction, :display_action_effects
  def display_action_effects(target, action = nil)
    gamebaker_compatibility_dispaction(target, action)
    update_phase4_step5
  end
  
  alias_method :gamebaker_compatibility_displayanim, :display_animation
  def display_animation(targets, animation_id)
    update_phase4_step3
    gamebaker_compatibility_displayanim(targets, animation_id)
    update_phase4_step4
  end    

  if GameBaker::BattleCompatibilityType == 1
    
    def end_actor_select; end_target_actor_selection; end
    def end_enemy_select; end_target_enemy_selection; end
    def end_item_select; end_item_selection; end
    def end_skill_select; end_skill_selection; end
    def judge; return judge_win_loss; end
    def make_item_action_result; execute_action_item; end
    def make_skill_action_result; execute_action_skill; end
    def phase3_next_actor; next_actor; end
    def phase3_prior_actor; prior_actor; end
    def phase3_setup_command_window; start_actor_command_selection; end
    def start_actor_select; start_target_actor_selection; end
    def start_enemy_select; start_target_enemy_selection; end
    def start_item_select; start_item_selection; end
    def start_phase2; start_party_command_selection; end
    def start_phase4; start_main; end
    def start_phase5; process_victory; end
    def start_skill_select; start_skill_selection; end
    def update_phase2; update_party_command_selection; end
    def update_phase2_escape; process_escape; end
    def update_phase3; update_actor_command_selection; end
    def update_phase3_actor_select; update_target_actor_selection; end
    def update_phase3_basic_command; update_actor_command_selection; end
    def update_phase3_enemy_select; update_target_enemy_selection; end
    def update_phase3_item_select; update_item_selection; end
    def update_phase3_skill_select; update_skill_selection; end
    def update_phase4_step1; process_action; end
    def update_phase4_step2; execute_action; end
    def update_phase4_step6; process_action; end
      
  elsif GameBaker::BattleCompatibilityType == 2
      
    def end_actor_select; end
    def end_enemy_select; end
    def end_item_select; end
    def end_skill_select; end
    def make_item_action_result; end
    def make_skill_action_result; end
    def phase3_next_actor; end
    def phase3_prior_actor; end
    def phase3_setup_command_window; end
    def start_actor_select; end
    def start_enemy_select; end
    def start_item_select; end
    def start_phase2; end
    def start_phase4; end
    def start_phase5; end
    def start_skill_select; end
    def update_phase2; end
    def update_phase2_escape; end
    def update_phase3; end
    def update_phase3_actor_select; end
    def update_phase3_basic_command; end
    def update_phase3_enemy_select; end
    def update_phase3_item_select; end
    def update_phase3_skill_select; end
    def update_phase4_step1; end
    def update_phase4_step2; end
    def update_phase4_step6; end
      
    alias_method :gamebaker_compatibility_endactor, :end_target_actor_selection
    def end_target_actor_selection
      gamebaker_compatibility_endactor
      end_actor_select
    end
    
    alias_method :gamebaker_compatibility_endenemy, :end_target_enemy_selection
    def end_target_enemy_selection
      gamebaker_compatibility_endenemy
      end_enemy_select
    end
    
    alias_method :gamebaker_compatibility_enditem, :end_item_selection
    def end_item_selection
      gamebaker_compatibility_enditem
      end_item_select
    end
    
    alias_method :gamebaker_compatibility_endskill, :end_skill_selection
    def end_skill_selection
      gamebaker_compatibility_endskill
      end_skill_select
    end
    
    alias_method :gamebaker_compatibility_judge, :judge_win_loss
    def judge; return gamebaker_compatibility_judge; end
    def judge_win_loss; return judge; end

    alias_method :gamebaker_compatibility_execitem, :execute_action_item
    def execute_action_item
      gamebaker_compatibility_execitem
      make_item_action_result
    end  

    alias_method :gamebaker_compatibility_execskill, :execute_action_skill
    def execute_action_skill
      gamebaker_compatibility_execskill
      make_skill_action_result
    end  

    alias_method :gamebaker_compatibility_nextactor, :next_actor
    def next_actor
      gamebaker_compatibility_nextactor
      phase3_next_actor
    end  

    alias_method :gamebaker_compatibility_prioractor, :prior_actor
    def prior_actor
      gamebaker_compatibility_prioractor
      phase3_prior_actor
    end  

    alias_method :gamebaker_compatibility_startactorc, :start_actor_command_selection
    def start_actor_command_selection
      gamebaker_compatibility_startactorc
      phase3_setup_command_window
    end  

    alias_method :gamebaker_compatibility_startactor, :start_target_actor_selection
    def start_target_actor_selection
      gamebaker_compatibility_startactor
      start_actor_select
    end  

    alias_method :gamebaker_compatibility_startenemy, :start_target_enemy_selection
    def start_target_enemy_selection
      gamebaker_compatibility_startenemy
      start_enemy_select
    end  

    alias_method :gamebaker_compatibility_startitem, :start_item_selection
    def start_item_selection
      gamebaker_compatibility_startitem
      start_item_select
    end

    alias_method :gamebaker_compatibility_startskill, :start_skill_selection
    def start_skill_selection
      gamebaker_compatibility_startskill
      start_skill_select
    end

    alias_method :gamebaker_compatibility_startparty, :start_party_command_selection
    def start_party_command_selection
      gamebaker_compatibility_startparty
      start_phase2
    end

    alias_method :gamebaker_compatibility_startmain, :start_main
    def start_main
      gamebaker_compatibility_startmain
      start_phase4
    end

    alias_method :gamebaker_compatibility_procvictory, :process_victory
    def process_victory
      gamebaker_compatibility_procvictory
      start_phase5
    end

    alias_method :gamebaker_compatibility_partycom, :update_party_command_selection
    def update_party_command_selection
      gamebaker_compatibility_partycom
      update_phase2
    end

    alias_method :gamebaker_compatibility_procescape, :process_escape
    def process_escape
      gamebaker_compatibility_procescape
      update_phase2_escape
    end

    alias_method :gamebaker_compatibility_procaction, :process_action
    def process_action
      update_phase4_step6
      gamebaker_compatibility_procaction
      update_phase4_step1
    end

    alias_method :gamebaker_compatibility_execaction, :execute_action
    def execute_action
      gamebaker_compatibility_execaction
      update_phase4_step2
    end    
    
    alias_method :gamebaker_compatibility_updactor, :update_actor_command_selection
    def update_actor_command_selection
      gamebaker_compatibility_updactor
      update_phase3
      update_phase3_basic_command
    end

    alias_method :gamebaker_compatibility_updtactor, :update_target_actor_selection
    def update_target_actor_selection
      gamebaker_compatibility_updtactor
      update_phase3_actor_select
    end

    alias_method :gamebaker_compatibility_updenemy, :update_target_enemy_selection
    def update_target_enemy_selection
      gamebaker_compatibility_updenemy
      update_phase3_enemy_select
    end

    alias_method :gamebaker_compatibility_upditem, :update_item_selection
    def update_item_selection
      gamebaker_compatibility_upditem
      update_phase3_item_select
    end

    alias_method :gamebaker_compatibility_updskill, :update_skill_selection
    def update_skill_selection
      gamebaker_compatibility_updskill
      update_phase3_skill_select
    end

  elsif GameBaker::BattleCompatibilityType == 3
      
    def end_actor_select; gamebaker_compatibility_endactor; end
    def end_enemy_select; gamebaker_compatibility_endenemy; end
    def end_item_select; gamebaker_compatibility_enditem; end
    def end_skill_select; gamebaker_compatibility_endskill; end
    def make_item_action_result; gamebaker_compatibility_execitem; end
    def make_skill_action_result; gamebaker_compatibility_execskill; end
    def phase3_next_actor; gamebaker_compatibility_nextactor; end
    def phase3_prior_actor; gamebaker_compatibility_prioractor; end
    def phase3_setup_command_window; gamebaker_compatibility_startactorc; end
    def start_actor_select; gamebaker_compatibility_startactor; end
    def start_enemy_select; gamebaker_compatibility_startenemy; end
    def start_item_select; gamebaker_compatibility_startitem; end
    def start_phase2; gamebaker_compatibility_startparty; end
    def start_phase4; gamebaker_compatibility_startmain; end
    def start_phase5; gamebaker_compatibility_procvictory; end
    def start_skill_select; gamebaker_compatibility_startskill; end
    def update_phase2; gamebaker_compatibility_partycom; end
    def update_phase2_escape; gamebaker_compatibility_procescape; end
    def update_phase3; gamebaker_compatibility_updactor; end
    def update_phase3_actor_select; gamebaker_compatibility_updtactor; end
    def update_phase3_basic_command; end
    def update_phase3_enemy_select; gamebaker_compatibility_updenemy; end
    def update_phase3_item_select; gamebaker_compatibility_upditem; end
    def update_phase3_skill_select; gamebaker_compatibility_updskill; end
    def update_phase4_step1; gamebaker_compatibility_procaction; end
    def update_phase4_step2; gamebaker_compatibility_execaction; end
    def update_phase4_step6; end
      
    alias_method :gamebaker_compatibility_endactor, :end_target_actor_selection
    def end_target_actor_selection
      end_actor_select
    end
    
    alias_method :gamebaker_compatibility_endenemy, :end_target_enemy_selection
    def end_target_enemy_selection
      end_enemy_select
    end
    
    alias_method :gamebaker_compatibility_enditem, :end_item_selection
    def end_item_selection
      end_item_select
    end
    
    alias_method :gamebaker_compatibility_endskill, :end_skill_selection
    def end_skill_selection
      end_skill_select
    end
    
    alias_method :gamebaker_compatibility_judge, :judge_win_loss
    def judge; return gamebaker_compatibility_judge; end
    def judge_win_loss; return judge; end

    alias_method :gamebaker_compatibility_execitem, :execute_action_item
    def execute_action_item
      make_item_action_result
    end  

    alias_method :gamebaker_compatibility_execskill, :execute_action_skill
    def execute_action_skill
      make_skill_action_result
    end  

    alias_method :gamebaker_compatibility_nextactor, :next_actor
    def next_actor
      phase3_next_actor
    end  

    alias_method :gamebaker_compatibility_prioractor, :prior_actor
    def prior_actor
      phase3_prior_actor
    end  

    alias_method :gamebaker_compatibility_startactorc, :start_actor_command_selection
    def start_actor_command_selection
      phase3_setup_command_window
    end  

    alias_method :gamebaker_compatibility_startactor, :start_target_actor_selection
    def start_target_actor_selection
      start_actor_select
    end  

    alias_method :gamebaker_compatibility_startenemy, :start_target_enemy_selection
    def start_target_enemy_selection
      start_enemy_select
    end  

    alias_method :gamebaker_compatibility_startitem, :start_item_selection
    def start_item_selection
      start_item_select
    end

    alias_method :gamebaker_compatibility_startskill, :start_skill_selection
    def start_skill_selection
      start_skill_select
    end

    alias_method :gamebaker_compatibility_startparty, :start_party_command_selection
    def start_party_command_selection
      start_phase2
    end

    alias_method :gamebaker_compatibility_startmain, :start_main
    def start_main
      start_phase4
    end

    alias_method :gamebaker_compatibility_procvictory, :process_victory
    def process_victory
      start_phase5
    end

    alias_method :gamebaker_compatibility_partycom, :update_party_command_selection
    def update_party_command_selection
      update_phase2
    end

    alias_method :gamebaker_compatibility_procescape, :process_escape
    def process_escape
      update_phase2_escape
    end

    alias_method :gamebaker_compatibility_procaction, :process_action
    def process_action
      update_phase4_step6
      update_phase4_step1
    end

    alias_method :gamebaker_compatibility_execaction, :execute_action
    def execute_action
      update_phase4_step2
    end    
    
    alias_method :gamebaker_compatibility_updactor, :update_actor_command_selection
    def update_actor_command_selection
      update_phase3
      update_phase3_basic_command
    end

    alias_method :gamebaker_compatibility_updtactor, :update_target_actor_selection
    def update_target_actor_selection
      update_phase3_actor_select
    end

    alias_method :gamebaker_compatibility_updenemy, :update_target_enemy_selection
    def update_target_enemy_selection
      update_phase3_enemy_select
    end

    alias_method :gamebaker_compatibility_upditem, :update_item_selection
    def update_item_selection
      update_phase3_item_select
    end

    alias_method :gamebaker_compatibility_updskill, :update_skill_selection
    def update_skill_selection
      update_phase3_skill_select
    end
  end
end
  

  
class Scene_Load
  def initialize; $scene = Scene_File.new(false,true,false); end
end

class Scene_Save
  def initialize; $scene = Scene_File.new(true,false,false); end
end
  
class Spriteset_Battle
  attr_reader :viewport1, :viewport2
end

class Window_InputNumber < Window_NumberInput
end

class Window_Selectable
  attr_accessor :column_max, :item_max
end