Cerco questi 3 script

Squall_Leonheart · March 29, 2009

Dunque siccome con il tasto cerca non ho trovato niente,vi porgo qui la richiesta di questi 3 script(ammesso che esistanoxD)

1)Camminata diagonale

Descrizione:Una volta avevo una demo in cui era inserita a camminata diagonale con il rispettivo frame + la camminata fluida,per farla breve c'era un'animazione a 9 frame per tutti e 8 i lati

2)Limit Break

Descrizione:Sistema di tecniche speciale alla FFVII,non so se sia stato creato però provoXDPossibilmente compatibile con l'RTAB

3)In pratica vorrei che per esempio in un panorama dover c'è una prateria in primo piano e una casa in secondo,più l'eroe si allontani più si rimpiccioliscie il chara,potrei farlo ad eventi ma credo che gli script evitano dei rallentamenti.

Scusate se sono seccante ma credo che il forum serva a questo^^

bombolo · March 29, 2009

Per il terzo forse ti riferisci al mode07? Perché il rimpicciolimento te lo fa in automatico, ma devi settare un angolo di inclinazione della mappa!

MasterSion · March 29, 2009

del secondo non sono sicurissimo che sia presente in questo forum però esiste, invece per quanto riguarda la prima richiesta c'è vai nella sezione script e cerca meglio...

ùil 3 mode 07

Narutofan95 · March 29, 2009

Per il primo della camminata diagonale c'è quello di Dad, ma funziona senza le 9 pose.

http://www.rpg2s.net/forum/index.php?showtopic=581

Amos_MHF · March 29, 2009

Intanto ecco il Limit break, ti ci ho inserito anche il sistema di barre che permette di visualizzare quella della limit.

#==============================================================================
# *** Limit Break (DVV's)										  (03-18-2007)
# *** Version 1.6
#------------------------------------------------------------------------------
# by DerVVulfman
# 
#   This system is a revamped & rewritten system that disables 'element-tagged'
#   skills until the hero's limitbreak bar is filled.   Once the skill is used,
#   the skill becomes disabled again.   Works with and without the RTAB system.
#   
#   One feature  that was sadly lacking in all other systems  was the inability
#   to fill the limitbreak bar with item damage.   Previous systems only looked
#   to damage inflicted through attacks and skill use.   Items such as grenades
#   were entirely overlooked.
#
#   It is still designed  'menu-less'  so there would be  no conflicts with any
#   custom menu scripts.  However,  with a little work, making a menu system to
#   change an actor's limit break fill-type (Attack/Defend/Guard) can be accom-
#   plished fairly easily... for the script literate.  :)
#
#   It still requires Cogwheel's HP/SP/EXP Gauge script to draw the Limit Break
#   bar, unless a suitable Bar Drawing script is available.   However,  without 
#   the bar drawing script, you will not get an error.   You just won't see the
#   bars on the screen.   Previous scripts  either had  their own 'cheaper' bar
#   rendering system, or had 'REQUIRED' scripts that without 'em... crashed.
#
#   Bug reported by link2795 for healing items crashing the game when used with
#   the RTAB system.  Bug caught and squashed.
#
#   Removed Window_BattleStatus's 'Update' def as re-aliasation slowed the game
#   down without contributing to anything.  It was a bug in the KGC_OverDrive
#   and previous BattleStatus Mod script combined.
#
#   Converted the positioning system's CONSTANTS into ($)GLOBAL values that you
#   can edit and change from a script call.   That way, positioning of the bars
#   can be changed based on which menu  or battlestatus window you are using at
#   the time.
#
#   Added a feature to hide limit break bars from the menu and the battlestatus
#   screens. Simple enough... just fill the array with the ID of the heroes you
#   don't want to have visible bars.  As it TOO uses ($)GLOBAL values, you can
#   change it through a script call.
#
#   Added save/load feature so ($)GLOBAL values that are changed through script
#   calls can be recorded into the savegame files.
#
#==============================================================================

#==============================================================================
#						 * Configuration Section *
#==============================================================================

 # Name of the Limit Break element 
 LB_NAME   = "Limit Break"


 # Starting/Default Limit Break Setting
 LB_START  = 0   # 0 = Attack		  |  1 = Critical	  |  2 = Damaged
			  # 3 = Killed an enemy |  4 = Killed a Boss |  5 = Hero Died
			  # 6 = Victory		 |  7 = Escape/Flee   |  8 = Defending
			  # 9 = Lone Combatant  | 10 = Any Action	| 11 = Crit. Health
 

 # Enemy Bosses (by ID)
 # Related to the LB_Rate, it determines if points garnered through 'killing'
 # an ememy gives regular 'enemy' points or 'boss' points to your LB gauge.
 LB_BOSSES = [17]   # Set to enemy 17 (Skeleton)
 
 # Hidden Actors (by ID)
 # This array holds the ID number of Actors who hide their own Limit Break bars
 # in both the battle and menu screens.  Will only apply to both battle & menu.
 $lb_hidden = [3]  # Set to actor #3, Cyrus
 

 # Limit Break Max Value
 LB_MAX	= 1000
 
 # Limit Break Fill Rates
 # For flat rates & max value settings, the max value should not exceed LB_MAX.
 LB_RATE   = [  10,   50,  200,  # Hero Attacks the Enemy	(rate, min., max.)
			 25,   25, 1000,  # Hero delivers a CRITICAL! (rate, min., max.)
			 30,	1, 1000,  # Hero takes Damage		 (rate, min., max.)
			500,  750,  900,  # Fatalaties:  Enemy, Boss or Self (flat rate)
			200,  200,  100,  # Victory, Escape & Defending	  (flat rate)
			160,   40,  160]  # Loner, Action & Crit. Health	 (flat rate)
			
 
 # Flexible positioning system.  Default position appears under the STATUS txt.
 $lb_menu_on	= 1			  # If set to '1', the bar is shown in the menu.
 $lb_menu_pos   = [ 0,   0, 190] # Positioning in the menu:  X, Y, & bar width.
 $lb_battle_pos = [ 0,  64, 120] # Positioning in the battle menu.  Same setup.
 $lb_rtab_pos   = [ 0, -25, 111] # Position if using RTAB system.   Same setup.
 $lb_rtab_var   = [0, 40]		# Variable distances between hero's LB gauges.
 

 # Hidden Actors
 # This array holds the ID number of Actors who hide their own overdrive gauges
 # in both the battle and menu screens.
 $lb_hide	  = []
 
 # SE played when Limit Break filled
 LB_RING   = "006-System06"
 

 #----------------------------------------------------------------------------
 # Do not edit below unless you know what you're doing. The following code is
 # for automatic systems in the script. Values are edited or passed elsewhere.
 #----------------------------------------------------------------------------

 # Stores the battler id for item users (needed for non-RTAB systems)
 $item_user = nil
 # Obtain the Limit Break 'id' from the system
 $data_system = load_data("Data/System.rxdata")
 $lb_element_id = $data_system.elements.index(LB_NAME)
 
#==============================================================================
#					   * Configuration Section End *
#==============================================================================



#============================================================================== 
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles data surrounding the system. Backround music, etc.
#  is managed here as well. Refer to "$game_system" for the instance of 
#  this class.
#==============================================================================

class Game_System
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 # Additional values for the save/load feature
 attr_accessor :lb_mn					# menu on
 attr_accessor :lb_mp					# menu position
 attr_accessor :lb_bp					# battle position
 attr_accessor :lb_rp					# rtab position
 attr_accessor :lb_rv					# rtab variance
 attr_accessor :lb_h					 # hidden
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 alias lb_init initialize
 def initialize
# Perform the original call
lb_init
# Create the savable values
@lb_mn  = 0
@lb_mp  = []
@lb_bp  = []
@lb_rp  = []
@lb_rv  = []
@lb_h   = []
 end  
end  



#==============================================================================
# ** Scene_Save
#------------------------------------------------------------------------------
#  This class performs save screen processing.
#==============================================================================

class Scene_Save < Scene_File
 #--------------------------------------------------------------------------
 # * Write Save Data
 #	 file : write file object (opened)
 #--------------------------------------------------------------------------
 alias lb_wsd write_save_data
 def write_save_data(file)
# Store the globals
$game_system.lb_mn  = $lb_menu_on
$game_system.lb_mp  = $lb_menu_pos
$game_system.lb_bp  = $lb_battle_pos
$game_system.lb_rp  = $lb_rtab_pos
$game_system.lb_rv  = $lb_rtab_var
$game_system.lb_h   = $lb_hide
# Perform the original call
lb_wsd(file)
 end
end



#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  This class performs load screen processing.
#==============================================================================

class Scene_Load < Scene_File
 #--------------------------------------------------------------------------
 # * Read Save Data
 #	 file : file object for reading (opened)
 #--------------------------------------------------------------------------
 alias lb_rsd read_save_data
 def read_save_data(file)
#Perform the original call
lb_rsd(file)
# ReStore the globals
$lb_menu_on	= $game_system.lb_mn
$lb_menu_pos   = $game_system.lb_mp
$lb_battle_pos = $game_system.lb_bp
$lb_rtab_pos   = $game_system.lb_rp
$lb_rtab_var   = $game_system.lb_rv
$lb_hide	   = $game_system.lb_h
 end
end



#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
#  This class deals with battlers. It's used as a superclass for the Game_Actor
#  and Game_Enemy classes.
#==============================================================================

class Game_Battler
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------  
 attr_accessor :base_damage
 #--------------------------------------------------------------------------
 # * Applying Normal Attack Effects (Edited)
 #	 attacker : battler
 #--------------------------------------------------------------------------
 alias lb_attack_effect attack_effect
 def attack_effect(attacker)
# Attach base damage to battler (for self.base_damage)
@base_damage = nil
# Execute the original process
result = lb_attack_effect(attacker)
# Set current damage (rtab or not)
current_dmg = self.damage
if $rtab_detected; current_dmg = self.damage[attacker]; end
# Set crit flag (rtab or not)
current_crit = self.critical
if $rtab_detected; current_crit = self.critical[attacker]; end
# Calculate basic damage
if @base_damage == nil
  @base_damage = 
  [attacker.atk - self.pdef / 2, 0].max * (20 + attacker.str) / 20
end
# When actual physical damage is applied
if result && current_dmg.is_a?(Numeric) && self.base_damage > 0
  # When HERO attacking the enemy (and tagged for 'Attack')
  if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && attacker.lb_type == 0 
	# Limit Break growth calculation
	lb_calc = current_dmg * LB_RATE[0] * 10 / self.base_damage
	# Adjust Limit Break growth between min & max values
	lb_add = [[lb_calc, LB_RATE[1]].max, LB_RATE[2]].min
	# OD gauge increase
	attacker.limitbreak += lb_add
  end
  # If the HERO made a critical hit on the Enemy
  if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && attacker.lb_type == 1 
	if current_crit
	  # Limit Break growth calculation
	  lb_calc = current_dmg * LB_RATE[3] * 10 / self.base_damage
	  # Adjust Limit Break growth between min & max values
	  lb_add = [[lb_calc, LB_RATE[4]].max, LB_RATE[5]].min
	  # OD gauge increase
	  attacker.limitbreak += lb_add  
	end
  end
  # When HERO is damaged by the enemy (and tagged for 'Damaged')
  if attacker.is_a?(Game_Enemy) && self.is_a?(Game_Actor) && self.lb_type == 2 
	lb_calc = current_dmg * LB_RATE[6] * 10 / self.maxhp
	# Adjust Limit Break growth between min & max values
	lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
	self.limitbreak += lb_add
  end
  # IF a battler has died
  if self.dead?
	# Regular killing move check.
	if attacker.is_a?(Game_Actor) && attacker.lb_type == 3
	  attacker.limitbreak += LB_RATE[9]  
	# Killed a boss enemy  
	elsif attacker.is_a?(Game_Actor) && attacker.lb_type == 4 &&
	  LB_BOSSES.include?(self.id)
	  attacker.limitbreak += LB_RATE[10]  
	end
	# Hero dies
	if self.is_a?(Game_Actor) && self.lb_type == 5
	  self.limitbreak += LB_RATE[11]  
	end		
  end
end
return result
 end
 #--------------------------------------------------------------------------
 # * Apply Skill Effects
 #	 user  : the one using skills (battler)
 #	 skill : skill
 #--------------------------------------------------------------------------  
 alias lb_skill_effect skill_effect  
 def skill_effect(user, skill)
# Attach base damage to battler (for self.base_damage)
@base_damage = nil
# Execute the original process
result = lb_skill_effect(user, skill)
# Set current damage (rtab or not)
current_dmg = self.damage
if $rtab_detected; current_dmg = self.damage[user]; end
# Recalculate the base (unadjusted) damage
if @base_damage == nil
  # Calculate power
  power = skill.power + user.atk * skill.atk_f / 100
  if power > 0
	power -= self.pdef * skill.pdef_f / 200
	power -= self.mdef * skill.mdef_f / 200
	power = [power, 0].max
  end
  # Calculate rate
  rate = 20
  rate += (user.str * skill.str_f / 100)
  rate += (user.dex * skill.dex_f / 100)
  rate += (user.agi * skill.agi_f / 100)
  rate += (user.int * skill.int_f / 100)
  # Calculate basic damage
  @base_damage = power * rate / 20
end
# When actual physical damage is applied
if result && current_dmg.is_a?(Numeric) && self.base_damage > 0
  # When HERO attacking the enemy (and tagged for 'Attack')
  if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && user.lb_type == 0
	# Limit Break growth calculation
	lb_calc = current_dmg * LB_RATE[0] * 10 / self.base_damage
	# Adjust Limit Break growth between min & max values
	lb_add = [[lb_calc, LB_RATE[1]].max, LB_RATE[2]].min
	# OD gauge increase
	user.limitbreak += lb_add
  end
  # When HERO is damaged by the enemy (and tagged for 'Damaged')
  if user.is_a?(Game_Enemy) && self.is_a?(Game_Actor) && self.lb_type == 2
	lb_calc = current_dmg * LB_RATE[6] * 10 / self.maxhp
	# Adjust Limit Break growth between min & max values
	lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
	self.limitbreak += lb_add
  end
  # IF a battler has died
  if self.dead?
	# Regular killing move check.
	if user.is_a?(Game_Actor) && user.lb_type == 3
	  user.limitbreak += LB_RATE[9]  
	# Killed a boss enemy  
	elsif user.is_a?(Game_Actor) && user.lb_type == 4 &&
	  LB_BOSSES.include?(self.id)
	  user.limitbreak += LB_RATE[10]  
	end
	# Hero dies
	if self.is_a?(Game_Actor) && self.lb_type == 5
	  self.limitbreak += LB_RATE[11]  
	end		
  end
end
# When limitbreak skill is used
if user.is_a?(Game_Actor) && skill.element_set.include?($lb_element_id)
  # Reset gauge
  user.limitbreak = 0
end
return result
 end
 #--------------------------------------------------------------------------
 # * Application of Item Effects
 #	 item : item
 #--------------------------------------------------------------------------
 alias lb_item_effect item_effect  
 def item_effect(item, battler = @active_battler)
# Attach base damage to battler (for self.base_damage)
@base_damage = nil
# Set 'user' to the current battler (and ensure if RTAB)
user = $item_user
if $rtab_detected; user = battler; end
# Execute the original process (RTAB or not)
if $rtab_detected
  result = lb_item_effect(item, user)
else
  result = lb_item_effect(item)
end
# Set current damage (rtab or not)
current_dmg = self.damage
if $rtab_detected; current_dmg = self.damage[user]; end
# Recalculate the base (unadjusted) damage
if @base_damage == nil
  #Calculate power
  power = maxhp * item.recover_hp_rate / 100 + item.recover_hp
  if power < 0
	power += self.pdef * item.pdef_f / 20
	power = [power, 0].min
  end
  # Set damage value and reverse item power amount
  @base_damage = -power
end
# When actual physical damage is applied
if result && current_dmg.is_a?(Numeric) && self.base_damage > 0
  # When HERO attacking the enemy (and tagged for 'Attack')
  if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && user.lb_type == 0
	# Limit Break growth calculation
	lb_calc = current_dmg * LB_RATE[0] * 10 / self.base_damage
	# Adjust Limit Break growth between min & max values
	lb_add = [[lb_calc, LB_RATE[1]].max, LB_RATE[2]].min
	# OD gauge increase
	user.limitbreak += lb_add
  end
  # When HERO is damaged by the enemy (and tagged for 'Damaged')
  if user.is_a?(Game_Enemy) && self.is_a?(Game_Actor) && self.lb_type == 2
	lb_calc = current_dmg * LB_RATE[6] * 10 / self.maxhp
	# Adjust Limit Break growth between min & max values
	lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
	self.limitbreak += lb_add
  end
  # IF a battler has died
  if self.dead?
	# Regular killing move check.
	if user.is_a?(Game_Actor) && user.lb_type == 3
	  user.limitbreak += LB_RATE[9]  
	# Killed a boss enemy  
	elsif user.is_a?(Game_Actor) && user.lb_type == 4 &&
	  LB_BOSSES.include?(self.id)
	  user.limitbreak += LB_RATE[10]  
	end
	# Hero dies
	if self.is_a?(Game_Actor) && self.lb_type == 5
	  self.limitbreak += LB_RATE[11]  
	end		
  end
end
return result
 end
end



#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler 
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader   :limitbreak			   # Limitbreak value
 attr_accessor :lb_type				  # Limitbreak action type
 attr_accessor :limitbreak_ring		  # Limit Break Ring Checker
 #--------------------------------------------------------------------------
 # * Setup
 #	 actor_id : actor ID
 #--------------------------------------------------------------------------
 alias lb_setup setup
 def setup(actor_id)
# Perform the original call
lb_setup(actor_id)
@limitbreak = 0		   # Reset Limit Break gauge to zero
@lb_type = LB_START	   # Set the Limit Break type to 'config' settings.
@limitbreak_ring = false  # Turn the 'ring' off
 end
 #--------------------------------------------------------------------------
 # * Determine if Skill can be Used
 #	 skill_id : skill ID
 #--------------------------------------------------------------------------
 alias lb_skill_can_use? skill_can_use?
 def skill_can_use?(skill_id)
# Get result from original call
result = lb_skill_can_use?(skill_id)
# Return if already disabled
return if result == false
# Obtain skill from database
skill = $data_skills[skill_id]
# Only perform if skill
if skill != nil
  # Only perform if includes the Element
  if skill.element_set.include?($lb_element_id)
	# If the limitbreak bar is filled, skill is available
	if self.limitbreak == LB_MAX
	  result = true
	# Otherwise, it isn't
	else
	  result = false
	end
  end
end
return result & super
 end 
 #--------------------------------------------------------------------------
 # * Adjust the limitbreak value (permits addition & keeps within range)
 #--------------------------------------------------------------------------
 def limitbreak=(limitbreak)
@limitbreak = limitbreak
@limitbreak = LB_MAX if @limitbreak > LB_MAX 
@limitbreak = 0 if @limitbreak < 0
 end
 #--------------------------------------------------------------------------
 # * Acquire Limit Break value (nil values won't cause errors now)
 #--------------------------------------------------------------------------
 def limitbreak
# Return 0 if nil (prevent errors)
@limitbreak = 0 if @limitbreak == nil
return @limitbreak
 end
end



#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================
class Window_Base
 #--------------------------------------------------------------------------
 # * Draw Actor Name
 #--------------------------------------------------------------------------
 alias lb_draw_actor_name draw_actor_name
 def draw_actor_name(actor, x, y)
# Only perform if the actor isn't hidden
unless $lb_hidden.include?(actor.id)
  # Set/reset the x, y and width of the Limit Break bar.	
  ox = $game_temp.in_battle ? $lb_battle_pos[0] : $lb_menu_pos[0]
  oy = $game_temp.in_battle ? $lb_battle_pos[1] : $lb_menu_pos[1]
  ow = $game_temp.in_battle ? $lb_battle_pos[2] : $lb_menu_pos[2]
  # To menu... or not to menu
  if $lb_menu_on == 1 && !$game_temp.in_battle
	draw_actor_lb(actor, x + ox, y + oy + 32, ow)
  elsif $game_temp.in_battle
	unless $rtab_detected
	  draw_actor_lb(actor, x + ox, y + oy + 32, ow)
	end
  end
end
lb_draw_actor_name(actor, x, y)
 end  
 #--------------------------------------------------------------------------
 # * Draw Battler Name
 #--------------------------------------------------------------------------
 # If the BattleStatus value of 'Alignment' exists
 if $bstat_align != nil
alias lb_draw_battler_name draw_battler_name
def draw_battler_name(actor, x, y)
  # Only perform if the actor isn't hidden
  unless $lb_hidden.include?(actor.id)
	# Set/reset the x, y and width of the Limit Break bar.	
	ox = $game_temp.in_battle ? $lb_battle_pos[0] : $lb_menu_pos[0]
	oy = $game_temp.in_battle ? $lb_battle_pos[1] : $lb_menu_pos[1]
	ow = $game_temp.in_battle ? $lb_battle_pos[2] : $lb_menu_pos[2]
	# To menu... or not to menu
	if $lb_menu_on == 1 && !$game_temp.in_battle
	  draw_actor_lb(actor, x + ox, y + oy + 32, ow)
	elsif $game_temp.in_battle
	  unless $rtab_detected
		draw_actor_lb(actor, x + ox, y + oy + 32, ow)
	  end
	end
  end
  lb_draw_battler_name(actor, x, y)
end	
 end
 #--------------------------------------------------------------------------
 # * Draw Overdrive Meter
 #--------------------------------------------------------------------------
 def draw_actor_lb(actor, x, y, width = 144)
if defined?(gauge_rect)
  rate = actor.limitbreak.to_f / LB_MAX
  plus_x = 0
  rate_x = 0
  plus_y = 25
  plus_width = 0
  rate_width = 100
  height = 10
  align1 = 1
  align2 = 2
  align3 = 0
  grade1 = 1
  grade2 = 0
  color1 = Color.new(0, 0, 0, 192)
  color2 = Color.new(255, 255, 192, 192)
  color3 = Color.new(0, 0, 0, 192)
  color4 = Color.new(64, 0, 0, 192)
  color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
  color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
  lb = (width + plus_width) * actor.limitbreak * rate_width / 100 / LB_MAX
  gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
	width, plus_width + width * rate_width / 100,
	height, lb, align1, align2, align3,
	color1, color2, color3, color4, color5, color6, grade1, grade2)
end	  
 end
end



#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  This window displays the status of all party members on the battle screen.
#==============================================================================
class Window_BattleStatus < Window_Base
 
 alias lb_init initialize
 def initialize
lb_init
if defined?(at_refresh)
  $rtab_detected = true
end
refresh
 end
 #--------------------------------------------------------------------------
 # * Full Limit Break Gauge SE
 #--------------------------------------------------------------------------
 def full_lb_se
if LB_RING != nil
  if LB_RING != ""
	Audio.se_play("Audio/SE/" + LB_RING, 80, 100)
  end
end
 end
 #--------------------------------------------------------------------------
 # * Frame renewal
 #--------------------------------------------------------------------------
 alias lb_refresh refresh
 def refresh(number = 0)
# Call the original def
if $rtab_detected
  lb_refresh(number)
else
  lb_refresh
end
# This block is needed only if RTAB in use
if $rtab_detected
  # Ensure bitmap available for bar drawing
  if self.contents == nil
	self.contents = Bitmap.new(width - 32 ,height - 32)
  end
  # Search through actors & draw bar if applicable
  if number == 0
	for i in 0...$game_party.actors.size
	  rtab_pos_x = $lb_rtab_pos[0] + ($lb_rtab_var[0] * i)
	  rtab_pos_y = $lb_rtab_pos[1] + ($lb_rtab_var[1] * i)
	  unless $lb_hidden.include?($game_party.actors[i].id)
		draw_actor_lb($game_party.actors[i], rtab_pos_x, rtab_pos_y+10,  $lb_rtab_pos[2])
	  end
	end
  else
	if $game_party.actors[number].is_a?(Game_Actor)
	  rtab_pos_x = $lb_rtab_pos[0] + ($lb_rtab_var[0] * number)
	  rtab_pos_y = $lb_rtab_pos[1] + ($lb_rtab_var[1] * number)
	  unless $lb_hidden.include?($game_party.actors[number].id)
		draw_actor_lb($game_party.actors[number], rtab_pos_x, rtab_pos_y+10, $lb_rtab_pos[2])
	  end
	end
  end
end
# Go through the Actors
$game_party.actors.each { |actor|
  # Only perform if the actor exists
  next unless actor.exist?
  # When the Limit Break gauge is set to zero,
  # Reset the Limit Break Ringer to false
  if actor.limitbreak == 0
	actor.limitbreak_ring = false
  end
  # When the Overdrive Ringer hasn't rung
  if actor.limitbreak_ring == false
	# But, if the Overdrive Bar is filled
	if actor.limitbreak == LB_MAX
	  # Play the Overdrive Sound Effect
	  full_lb_se
	  # And Set the Overdrive Ringer to true
	  actor.limitbreak_ring = true
	end
  end
  }		
 end
end



#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle
 #--------------------------------------------------------------------------
 # * Battle Ends
 #	 result : results (0:win 1:lose 2:escape)
 #--------------------------------------------------------------------------
 alias lb_battle_end battle_end
 def battle_end(result)
# Branch on Battle condition
case result
when 0 # Victory
  $game_party.actors.each { |actor|
  next unless actor.exist?
  # For each actor who won & set to Victory
  if actor.lb_type == 6
	actor.limitbreak += LB_RATE[12]
  end
  }
when 1 # Escape
  $game_party.actors.each { |actor|
  next unless actor.exist?
  # For each actor who ran & set to Escape
  if actor.lb_type == 7
	actor.limitbreak += LB_RATE[13]
  end
  }
end
# Defeat
lb_battle_end(result)
 end
 #--------------------------------------------------------------------------
 # * Frame Update (main phase step 2 : start action)
 #--------------------------------------------------------------------------
 alias lb_adddate_p4_s2 update_phase4_step2
 def update_phase4_step2(battler = @active_battler)
# Perform only if actor
if battler.is_a?(Game_Actor)
  # Reset adding value
  lb_add = 0
  # Branch on LimitBreak type
  case battler.lb_type
  when 8 # When Defending
	if battler.current_action.kind = 0
	  if battler.current_action.basic == 1
		lb_add = LB_RATE[14]
		print lb_add
	  end
	end
  when 9 # When it's a lone battler
	if $game_party.actors.size == 1
	  lb_add = LB_RATE[15]
	end
  when 10 # When performing ANY acton
	lb_add = LB_RATE[16]
  when 11 # If in CRITICAL
	if battler.hp <= @active_battler.maxhp / 4
	  lb_add = LB_RATE[17]
	end
  end
  # Add values to limitbreak
  battler.limitbreak += lb_add
end
# Perform the original call
if $rtab_detected; lb_adddate_p4_s2(battler); else; lb_adddate_p4_s2; end
 end
 #--------------------------------------------------------------------------
 # * Make Item Action Results
 #--------------------------------------------------------------------------  
 alias lb_miar make_item_action_result 
 def make_item_action_result(battler = @active_battler)
$item_user = battler
# Perform the original call
if $rtab_detected; lb_miar(battler); else; lb_miar; end
 end  
 #--------------------------------------------------------------------------
 # * Frame Update (main phase step 4 : animation for target)
 #--------------------------------------------------------------------------  
 alias lb_update_p4_s4 update_phase4_step4 
 def update_phase4_step4(battler = @active_battler)
 if $rtab_detected
  @status_window.update
  @status_window.refresh
 end
# Perform the original call
if $rtab_detected; lb_update_p4_s4(battler); else lb_update_p4_s4; end	
 end
end

#===========================================================================
# *** HP/MP/ATB/LimitBreak bar Slanted Style Compatible with RTAB ***
# *** Version 2.1
#---------------------------------------------------------------------------
# by Clive 
# based on Cogwheel's Bars and Sephiroth Spawn's Slanted Bars.
#---------------------------------------------------------------------------
# ----- GREAT THANKS to DerVVulfman for solving the lag problem
#------This is a plug and play script so it should work without any problem!
#=============================================================================

# If using with Limit Break, must paste BELOW the Limit Break script as it re-
# writes the 'Gauge drawing' system.  Will cause an error if not properly put.

# If used with Trickster's STEAL SCRIPT version 6 R1 (revision 1), then the
# height of RTAB's AT Bar (Draw Actor ATG) may not be smaller than 5 pixels 
# due to a float-to-float error.  A height of 6 pixels is the smallest.


#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
 #--------------------------------------------------------------------------
 # * Get the current EXP
 #--------------------------------------------------------------------------
 def now_exp
return @exp - @exp_list[@level]
 end
 #--------------------------------------------------------------------------
 # * Get the next level's EXP
 #--------------------------------------------------------------------------
 def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
 end
end


#==============================================================================
# ** Window_Base 
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================

class Window_Base < Window  
 
 #==========================================================================
 # * Draw Slant Bar(by SephirothSpawn)
 #==========================================================================
 def draw_slant_bar(x, y, min, max, width = 152, height = 6,
  bar_color = Color.new(150, 0, 0, 255),
  end_color = Color.new(255, 255, 60, 255))
# Draw Border
for i in 0..height
  self.contents.fill_rect(x + i, y + height - i, width + 1, 1, Color.new(50, 50, 50, 255))
end
# Draw Background
for i in 1..(height - 1)
  r = 100 * (height - i) / height + 0 * i / height
  g = 100 * (height - i) / height + 0 * i / height
  b = 100 * (height - i) / height + 0 * i / height
  a = 255 * (height - i) / height + 255 * i / height
  self.contents.fill_rect(x + i, y + height - i, width, 1, Color.new(r, b, g, a))
end
# Draws Bar
for i in 1..( (min.to_f / max.to_f) * width - 1)
  for j in 1..(height - 1)
	r = bar_color.red * (width - i) / width + end_color.red * i / width
	g = bar_color.green * (width - i) / width + end_color.green * i / width
	b = bar_color.blue * (width - i) / width + end_color.blue * i / width
	a = bar_color.alpha * (width - i) / width + end_color.alpha * i / width
	self.contents.fill_rect(x + i + j, y + height - j, 1, 1, Color.new(r, g, b, a))
  end
end
 end
 
 #==========================================================================
 # * Draw HP
 #	 actor : actor
 #	 x	 : draw spot x-coordinate
 #	 y	 : draw spot y-coordinate
 #	 width : draw spot width
 #==========================================================================
 alias :draw_actor_hp_hpsp :draw_actor_hp
 def draw_actor_hp(actor, x, y, width = 144)   
draw_slant_bar(x, y + 12, actor.hp, actor.maxhp, width, 6, 
  bar_color = Color.new(150, 0, 0, 255), 
  end_color = Color.new(255, 255, 60, 255))
draw_actor_hp_hpsp(actor, x, y, width)
  end
 #==========================================================================
 # * Draw SP
 #	 actor : actor
 #	 x	 : draw spot x-coordinate
 #	 y	 : draw spot y-coordinate
 #	 width : draw spot width
 #==========================================================================
 alias :draw_actor_sp_hpsp :draw_actor_sp
 def draw_actor_sp(actor, x, y, width = 144)
draw_slant_bar(x, y + 12, actor.sp, actor.maxsp, width, 6,
  bar_color = Color.new(0, 0, 155, 255), 
  end_color = Color.new(255, 255, 255, 255))
draw_actor_sp_hpsp(actor, x, y, width)
 end
 #==========================================================================
 # * Draw EXP
 #	 actor : actor
 #	 x	 : draw spot x-coordinate
 #	 y	 : draw spot y-coordinate
 #==========================================================================
 alias raz_bars_base_exp draw_actor_exp  
 def draw_actor_exp(actor, x, y)
if actor.level == 99
  draw_slant_bar(x, y + 18, 1, 1, 190, 6, bar_color = Color.new(0, 100, 0, 255), end_color = Color.new(0, 255, 0, 255))
else
  draw_slant_bar(x, y + 18, actor.now_exp, actor.next_exp, 190, 6, bar_color = Color.new(0, 100, 0, 255), end_color = Color.new(255, 255, 255, 255))
end
raz_bars_base_exp(actor, x, y)
 end
 #==========================================================================
 # * Draw Parameter
 #	 actor : actor
 #	 x	 : draw spot x-coordinate
 #	 y	 : draw spot y-coordinate
 #	 type  : parameter type (0-6)
 #==========================================================================
 alias raz_bars_base_parameter draw_actor_parameter  
 def draw_actor_parameter(actor, x, y, type)
case type
when 0
  para_color1 = Color.new(100,0,0)
  para_color2 = Color.new(255,0,0)
  para_begin = actor.atk
when 1
  para_color1 = Color.new(100,100,0)
  para_color2 = Color.new(255,255,0)
  para_begin = actor.pdef
when 2
  para_color1 = Color.new(100,0,100)
  para_color2 = Color.new(255,0,255)
  para_begin = actor.mdef
when 3
  para_color1 = Color.new(50,0,100)
  para_color2 = Color.new(50,0,255)
  para_begin = actor.str
when 4
  para_color1 = Color.new(0,100,0)
  para_color2 = Color.new(0,255,0)
  para_begin = actor.dex
when 5
  para_color1 = Color.new(50,0,50)
  para_color2 = Color.new(255,0,255)
  para_begin = actor.agi
when 6
  para_color1 = Color.new(0,100,100)
  para_color2 = Color.new(0,255,255)
  para_begin = actor.int
end
draw_slant_bar(x, y + 18, para_begin, 999, 155, 4, bar_color = para_color1,
  end_color = para_color2)
raz_bars_base_parameter(actor, x, y, type)
 end
 #=========================================================================
 # * Draw Actor ATG
 #	 actor : Actor
 #	 x	 : draw spot x-coordinate
 #	 y	 : draw spot y-coordinate
 #	 width : draw spot width
 #=========================================================================
 def draw_actor_atg(actor, x, y, width = 144, height = 6)
if @at_gauge == nil
  # plus_x:	 revised x-coordinate
  # rate_x:	 revised X-coordinate as (%)
  # plus_y:	 revised y-coordinate
  # plus_width: revised width
  # rate_width: revised width as (%)
  # height:	 Vertical width
  # align1: Type 1 ( 0: left justify  1: center justify 2: right justify )
  # align2: Type 2 ( 0: Upper stuffing 1: Central arranging  2:Lower stuffing )
  # align3: Gauge type 0:Left justify 1: Right justify
  @plus_x = 0
  @rate_x = 0
  @plus_y = 16
  @plus_width = 0
  @rate_width = 100
  @width = @plus_width + width * @rate_width / 100
  @height = 6
  @align1 = 0
  @align2 = 1
  @align3 = 0
  # Gradation settings:  grade1: Empty gauge   grade2:Actual gauge
  # (0:On side gradation   1:Vertically gradation	2: Slantedly gradation）
  grade1 = 1
  grade2 = 0
  # Color setting. color1: Outermost framework, color2: Medium framework
  # color3: Empty framework dark color, color4: Empty framework light/write color
  color1 = Color.new(0, 0, 0)
  color2 = Color.new(255, 255, 192)
  color3 = Color.new(0, 0, 0, 192)
  color4 = Color.new(0, 0, 64, 192)
  # Color setting of gauge
  # Usually color setting of the time
  color5 = Color.new(0, 64, 80)
  color6 = Color.new(255, 255, 255)#(0, 128, 160)
  # When gauge is MAX, color setting
  color7 = Color.new(80, 0, 0)
  color8 = Color.new(255, 255,255) #(240,0,0)
  # Color setting at time of cooperation skill use
  color9 = Color.new(80, 64, 32)
  color10 = Color.new(255, 255, 255) #(240, 192, 96)
  # Color setting at time of skill permanent residence
  color11 = Color.new(80, 0, 64)
  color12 = Color.new(255,255, 255) #(240, 0, 192)
  # Drawing of gauge
  gauge_rect_at(@width, @height, @align3, color1, color2, color3, color4,
	  color5, color6, color7, color8, color9, color10, color11, color12,
	  grade1, grade2)
end
# Variable at substituting the width of the gauge which is drawn
if actor.rtp == 0
  at = (width + @plus_width) * actor.atp * @rate_width / 10000
else
  at = (width + @plus_width) * actor.rt * @rate_width / actor.rtp / 100
end
# AT Width Check
if at > width
  at = width
end
# Revision such as the left stuffing central posture of gauge
case @align1
when 1
  x += (@rect_width - width) / 2
when 2
  x += @rect_width - width
end
case @align2
when 1
  y -= @height / 2
when 2
  y -= @height
end
# Draw Border
for i in 0..height
  self.contents.fill_rect(x + 1.5 + i, y + 12 + height - i, width - 2 , 3,
	Color.new(50, 50, 50, 255))
end
# Draw Background
for i in 1..(height - 1)
  r = 100 * (height - i) / height + 0 * i / height
  g = 100 * (height - i) / height + 0 * i / height
  b = 100 * (height - i) / height + 0 * i / height
  a = 255 * (height - i) / height + 255 * i / height
  self.contents.fill_rect(x + 1.5 + i, y + 12 + height - i, width - 3, 3, 
	Color.new(r, b, g, a))
end
# Rect_X control
if @align3 == 0
  rect_x = 0
else
  x += @width - at - 1
  rect_x = @width - at - 1
end

# Color setting of gauge
if at == width 
#Gauge drawing at the time of MAX
  for i in 0..height
	self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y -i + 
	@plus_y, @at_gauge, Rect.new(rect_x, @height * 2, at, @height))
  end
else
  if actor.rtp == 0
	for i in 0..height
	  # Usually gauge drawing of the time
	  self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y- i + 
		@plus_y, @at_gauge,Rect.new(rect_x, @height, at, @height))
	end
  else
	if actor.spell == true
	  for i in 0..height
		#Gauge drawing at time of cooperation skill use
		self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y - i + 
		  @plus_y, @at_gauge, Rect.new(rect_x, @height * 3, at, @height))
	  end
	else
	  for i in 0..height			  
		# Gauge drawing at time of skill permanent residence
		self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y - i +
		  @plus_y, @at_gauge, Rect.new(rect_x, @height * 4, at, @height))
	  end
	end
  end
end
 end
 #=========================================================================
 # * Draw Actor Limit Break Bar
 #	 actor : Actor
 #	 x	 : draw spot x-coordinate
 #	 y	 : draw spot y-coordinate
 #	 width : draw spot width
 #=========================================================================
 def draw_actor_lb(actor, x, y, width = 144)
rate = actor.limitbreak.to_f / LB_MAX
plus_x = 0
rate_x = 0
plus_y = 15
plus_width = 0
rate_width = 100
height = 7
lb = (width + plus_width) * actor.limitbreak * rate_width / 100 / LB_MAX
# Drawing of gauge
if actor.limitbreak == LB_MAX
  # Draw Silver Blue Bar
  draw_slant_bar(x + plus_x + width * rate_x / 100, y + plus_y, lb, width,
	width, height, od_color1 = Color.new(0,80,200,192), 
	od_color2 = Color.new(255,255,255,192))
else
  # Draw Green Bar
  draw_slant_bar(x + plus_x + width * rate_x / 100, y + plus_y, lb, width,
	width, height, od_color1 = Color.new(31, 128, 0, 128), 
	od_color2 = Color.new(255, 255, 191))
end
 end  
end

EDIT: Ecco lo script Prospective Sprites di Sephiroth Spawn, richiede le SDK ultima versione.

#==============================================================================
# ** Perspective Sprites
#------------------------------------------------------------------------------
# SephirothSpawn
# Version 1
# 2007-01-05
# SDK : Version 2.0+, Parts I & II
#------------------------------------------------------------------------------
# * Version History :
#
#   Version 1 ---------------------------------------------------- (2007-01-05)
#------------------------------------------------------------------------------
# * Requirements :
#
#   Method & Class Library (2.1+)
#------------------------------------------------------------------------------
# * Description :
#
#   This script was designed to manipulate event sprites to appear with
#   perspective. You can define perspective points on the map and scaling for
#   each perspective point. You may also define perspective regions, so when
#   an event is : at a specific point; within a defined rectangle; within a
#   defined circle, they will have altered perspective points and scaling.
#
#   How it works:
#
#   The events will zoom the distance they are from the defined perspective
#   point divided by the scale. If the focus point is 400 pixels away and
#   the scale is 800, the zoom will be 400 / 800. So the sprite will be
#   half of it's original size.
#------------------------------------------------------------------------------
# * Instructions :
#
#   Place The Script Below the SDK and Above Main.
#   To define focus points, scales and regions, refer to Customization.
#   To get the current zoom of an event, refer to Syntax.
#------------------------------------------------------------------------------
# * Customization :
#
#   Focus Points
#	- Focus_Points = { map_id => [real_x, real_y], ... }
#
#   Scaling
#	- Scaling	  = { map_id => n, ... }
#
#   Regions alter the focus points & scaling for characters in these regions
#
#   Direct Region (Specific Point)
#	- Drct_Regions = {
#		map_id => { [x, y] => [real_x, real_y, scaling], ...},
#		...
#	  }
#   Regions (Rectangular)
#	- Rect_Regions = { 
#		map_id => { [x, y, w, h] => [real_x, real_y, scaling], ... },
#		...
#	  }
#
#   Regions (Circular)
#	- Circ_Regions = {
#		map_id => { [x, y, r] => [real_x, real_y, scaling], ... },
#		... 
#	  }
#------------------------------------------------------------------------------
# * Syntax :
#
#   Getting Curren Zoom of character (Returns Float)
#	- <game_character>.zoom?
#==============================================================================

#------------------------------------------------------------------------------
# * SDK Log Script
#------------------------------------------------------------------------------
SDK.log('Perspective Sprites', 'SephirothSpawn', 1, '2007-01-05')
SDK.check_requirements(2.0, [2], {'Method & Class Library' => 2.1})

#------------------------------------------------------------------------------
# * Begin SDK Enable Test
#------------------------------------------------------------------------------
if SDK.enabled?('Perspective Sprites')
 
#==============================================================================
# ** Perspective
#==============================================================================

module Perspective
 #--------------------------------------------------------------------------
 # * Options
 #
 #  ~ Focus Points
 #	 - Focus_Points = { map_id => [real_x, real_y], ... }
 #
 #  ~ Scaling
 #	 - Scaling	  = { map_id => n, ... }
 #
 #  Regions alter the focus points & scaling for characters in these regions
 #
 #  ~ Direct Region (Specific Point)
 #	 - Drct_Regions = {
 #		 map_id => { [x, y] => [real_x, real_y, scaling], ...},
 #		 ...
 #	   }
 #  ~ Regions (Rectangular)
 #	 - Rect_Regions = { 
 #		 map_id => { [x, y, w, h] => [real_x, real_y, scaling], ... },
 #		 ...
 #	   }
 #
 #  ~ Regions (Circular)
 #	 - Circ_Regions = {
 #		 map_id => { [x, y, r] => [real_x, real_y, scaling], ... },
 #		 ... 
 #	   }
 #
 #--------------------------------------------------------------------------
 Focus_Points = {
2 => [320, - 480]
 }
 Scaling	  = {
2 => 640
 }
 Drct_Regions = {
# Example
# 1 => { [3, 3] => [0, 0, 200] }
 }
 Rect_Regions = {
# Example
# 1 => { [4, 4, 5, 5] => [1000, -200, 500] }
 }
 Circ_Regions = {
 }
 #--------------------------------------------------------------------------
 # * Get Focus Point
 #--------------------------------------------------------------------------
 def self.focus_point?(map_id)
return Focus_Points.has_key?(map_id) ? Focus_Points[map_id] : nil
 end
 #--------------------------------------------------------------------------
 # * Get Scaling
 #--------------------------------------------------------------------------
 def self.scaling?(map_id)
return Scaling.has_key?(map_id) ? Scaling[map_id] : 1
 end
 #--------------------------------------------------------------------------
 # * Direct Regions
 #--------------------------------------------------------------------------
 def self.drct_regions?(map_id)
return Drct_Regions.has_key?(map_id) ? Drct_Regions[map_id] : {}
 end
 #--------------------------------------------------------------------------
 # * Rect Regions
 #--------------------------------------------------------------------------
 def self.rect_regions?(map_id)
return Rect_Regions.has_key?(map_id) ? Rect_Regions[map_id] : {}
 end
 #--------------------------------------------------------------------------
 # * Circ Regions
 #--------------------------------------------------------------------------
 def self.circ_regions?(map_id)
return Circ_Regions.has_key?(map_id) ? Circ_Regions[map_id] : {}
 end
 #--------------------------------------------------------------------------
 # * Focus & Scale at Point
 #--------------------------------------------------------------------------
 def self.focus_and_scale?(map_id, x, y)
# Sets Key
key = [map_id, x, y]
# If Search Contains Key
if @searches.has_key?(key)
  # Returns Saved Data
  return @searches[key]
end
# Checks Direct Locations
self.drct_regions?(map_id).each do |xy, xys|
  return xys if x == xy[0] && y == xy[0]
end
# Checks Rect Regions
self.rect_regions?(map_id).each do |xywh, xys|
  x_, y_ = xywh[0],	  xywh[1]
  w, h = xywh[2], xywh[3]
  return xys if VR.in_rect_range?(x, y, x_, y_, w, h)
end
# Checks Circular Regions
self.circ_regions?(map_id).each do |xyr, xys|
  return xys if VR.in_range?(x, y, xyr[0], xyr[1], xyr[2])
end
# Save & Return Map Scaling
f, s = self.focus_point?(map_id), self.scaling?(map_id)
return (f.nil? ? [nil, nil, 1] : [f[0], f[1], s])
 end
 #--------------------------------------------------------------------------
 # * Get Searches (DO NOT ALTER)
 #--------------------------------------------------------------------------
 # Create Search Data
 @searches = {}
 # Load Map Data
 load_data('Data/MapInfos.rxdata').keys.each do |map_id|
# Get Map Data
map = load_data(sprintf('Data/Map%03d.rxdata', map_id))
# Pass Through Map Dimensions
for x in 0...map.width
  for y in 0...map.height
	# Save Map Scale
	@searches[[map_id, x, y]] = self.focus_and_scale?(map_id, x, y)
  end
end
 end
end

#==============================================================================
# ** Game_Map
#==============================================================================

class Game_Map
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader :p_focus_point
 attr_reader :p_scaling
 attr_reader :p_drct_regs
 attr_reader :p_rect_regs
 attr_reader :p_circ_regs
 #--------------------------------------------------------------------------
 # * Alias Listings
 #--------------------------------------------------------------------------
 alias_method :seph_spritepersp_gmap_suld,	:setup_load
 #--------------------------------------------------------------------------
 # * Setup
 #--------------------------------------------------------------------------
 def setup_load
# Original Setup Map Data
seph_spritepersp_gmap_suld
# Sets Perspective Properties
@p_focus_point = Perspective.focus_point?(@map_id)
@p_scaling	 = Perspective.scaling?(@map_id)
@p_drct_regs   = Perspective.drct_regions?(@map_id)
@p_rect_regs   = Perspective.rect_regions?(@map_id)
@p_circ_regs   = Perspective.circ_regions?(@map_id)
 end
 #--------------------------------------------------------------------------
 # * Focus and Scale?
 #--------------------------------------------------------------------------
 def focus_and_scale?(x, y)
return Perspective.focus_and_scale?(@map_id, x, y)
 end
end

#==============================================================================
# ** Game_Character
#==============================================================================

class Game_Character
 #--------------------------------------------------------------------------
 # * Perspective Zoom?
 #--------------------------------------------------------------------------
 def perspective_zoom?
# Gets Focus Points
f_x, f_y, scale = $game_map.focus_and_scale?(@x, @y)
# Calculates X & Y Difference
x_diff = (@real_x / 4 - f_x).abs
y_diff = (@real_y / 4 - f_y).abs
# Calculates Distance From Focus
distance = Math.sqrt(x_diff ** 2 + y_diff ** 2)
# Returns Zoom
return distance / scale.to_f
 end
end

#==============================================================================
# ** Sprite_Character
#==============================================================================

class Sprite_Character
 #--------------------------------------------------------------------------
 # * Alias Listings
 #--------------------------------------------------------------------------
 alias_method :seph_spritepersp_schr_update, :update
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
# Original Update
seph_spritepersp_schr_update
# Unless No Focus Point
unless $game_map.p_focus_point.nil?
  # If Visible
  if self.visible
	# Sets Zoom
	zoom = @character.perspective_zoom?
	self.zoom_x = zoom
	self.zoom_y = zoom
  end
end
 end
end

#------------------------------------------------------------------------------
# * End SDK Enable Test
#------------------------------------------------------------------------------
end

Edited March 29, 2009 by Amos_MHF

Squall_Leonheart · March 29, 2009

Dunque,grazie per avermi risposto,però ho riscontrato dei problemi,le limit funzionano ma con il sistema di battaglia normale e non con l'RATB.come risolvo?

Secondo non so dove prendere l'ultimo SDK per far funzionare lo script di Sephiroth Spawn e terzo riguardo la camminata diagonale ho trovato solo quella di Dad.

Come devo fare?

Squall_Leonheart · March 31, 2009

Dunque scusate per il doppio post ma in attesa di una risposta volevo segnalarvi che su rmpx.org ho trovato uno script delle limit break compatibile con l'RTAB,però non ci capisco molto e non so come usarlo,purtroppo non sono riuscito a capire l'autore,però dalla mia traduzione ne ho ricavato che non è nient'altro che una modifica del KGC_Overdrive...Qualcuno puoi aiutarmi ad usarlo?

#==============================================================================
# ** KGC_Overdrive
#------------------------------------------------------------------------------
#  When the privately drawn gauge becomes filled, the skill attached to it is
#  enabled.  
#Edited by MistTribe to make it more FF7 like. I used the KGC_Ringer script placed way at
#the bottom so if you edit the   OD_GAUGE_MAX(line 17) then you have make   
#OD_GAUGE_MAX(line 377) the same value. I set it to 500 as so it gains a little faster.
#==============================================================================

#==============================================================================
# * Customization Section *
#==============================================================================

module KGC
 
 # Overdrive gauge maximum.
 OD_GAUGE_MAX = 500
 
 # Overdrive gauge gain rate.
 # The order (index) and conditions are as follows:
 # Order(index) and conditions are as follows:
 #   0 = Attack	  1 = Damage
 #   2 = Victory	 3 = Escape
 #   4 = Alone	   5 = Action
 #   6 = Fatal
 #
 # The accumulation speed of '0'(Attack) and '1'(Damage)  changes based  on the
 # amount of damage. The higher the rate, the faster the overdrive gauge fills.
 OD_GAIN_RATE = [100, 100, 200, 100, 160, 100, 160]
end

 $imported = {} if $imported == nil
 $imported["LimitBreak"] = true

 if $game_special_elements == nil
$game_special_elements = {}
$data_system = load_data("Data/System.rxdata")
 end
 # OverDrive Attribute
 $game_special_elements["limitbreak"] = $data_system.elements.index("LimitBreak")


#==============================================================================
# ** Game_Battler (Part 3)
#==============================================================================

class Game_Battler

 attr_accessor :base_damage
 #--------------------------------------------------------------------------
 # * Applying Normal Attack Effects (Edited)
 #	 attacker : battler
 #--------------------------------------------------------------------------
 alias attack_effect_KGC_OverDrive attack_effect
 def attack_effect(attacker)
@base_damage = nil
# Execute the original process
result = attack_effect_KGC_OverDrive(attacker)
if @base_damage == nil
  # Retaining basic damage value
  @base_damage = [attacker.atk - self.pdef / 2, 0].max *
	(20 + attacker.str) / 20
end
# When the damage is received
if result && self.damage[attacker].is_a?(Numeric)
  # When attacking increase decision
  if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
	attacker.overdrive_type == 0 && self.base_damage > 0
	# OD gauge growth calculation
	od_up = [[self.damage[attacker] * KGC::OD_GAIN_RATE[0] * 10 /
	  self.base_damage, 1].max, 160].min
	# OD gauge increase
	attacker.overdrive += od_up
	# At the time of suffering damage increase decision
  elsif attacker.is_a?(Game_Enemy) && self.is_a?(Game_Actor) &&
	self.overdrive_type == 1 && self.base_damage > 0
	od_up = [self.damage[attacker] * KGC::OD_GAIN_RATE[1] * 10 / 
	  self.maxhp, 1].max
	self.overdrive += od_up
  end
end
return result
 end
 #--------------------------------------------------------------------------
 # * Apply Skill Effects (Edited)
 #	 user  : the one using skills (battler)
 #	 skill : skill
 #--------------------------------------------------------------------------  
 alias skill_effect_KGC_OverDrive skill_effect
 def skill_effect(user, skill)
@base_damage = nil
# Execute the original process
result = skill_effect_KGC_OverDrive(user, skill)
if @base_damage == nil
  #Calculating power
  power = skill.power + user.atk * skill.atk_f / 100
  if power > 0
	power -= self.pdef * skill.pdef_f / 200
	power -= self.mdef * skill.mdef_f / 200
	power = [power, 0].max
  end
  # Calculating magnification ratio
  rate = 20
  rate += (user.str * skill.str_f / 100)
  rate += (user.dex * skill.dex_f / 100)
  rate += (user.agi * skill.agi_f / 100)
  rate += (user.int * skill.int_f / 100)
  # Retaining the basic damage
  @base_damage = power * rate / 20
end
#When the damage is received
if result && self.damage[user].is_a?(Numeric)
  # When attacking increase decision
  if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) &&
	user.overdrive_type == 0 && self.base_damage > 0
	# OD gauge growth calculation
	od_up = [[self.damage[user] * KGC::OD_GAIN_RATE[0] * 10 / 
	  self.base_damage, 1].max, 160].min
	# OD gauge increase
	user.overdrive += od_up
	# At the time of suffering damage increase decision
  elsif user.is_a?(Game_Enemy) && self.is_a?(Game_Actor) &&
	self.overdrive_type == 1 && self.base_damage > 0
	od_up = [self.damage[user] * KGC::OD_GAIN_RATE[1] * 10 /
	  self.maxhp, 1].max
	self.overdrive += od_up
  end
end
# When overdrive skill is used
if user.is_a?(Game_Actor) &&
  skill.element_set.include?($game_special_elements["limitbreak"])
  user.overdrive = 0
end
return result
 end
end



#==============================================================================
# ** Game_Actor
#==============================================================================
 KGC_Game_Actor_first = "LimitBreak" unless defined?(KGC_Game_Actor)
 module KGC_Game_Actor
 #--------------------------------------------------------------------------
 # * Active decision of skill
 #--------------------------------------------------------------------------
 if defined?(skill_can_use?) && !@_skill_can_use_overdrive
alias skill_can_use_KGC_OverDrive skill_can_use?
 else
@_skill_can_use_overdrive = true
 end
 def skill_can_use?(skill_id)
result = true
skill = $data_skills[skill_id]
if skill != nil &&
  skill.element_set.include?($game_special_elements["limitbreak"])
  result = self.overdrive == KGC::OD_GAUGE_MAX
end
if defined?(skill_can_use_KGC_OverDrive)
  return result & skill_can_use_KGC_OverDrive(skill_id)
else
  return result & super
end
 end
 module_function :skill_can_use?
 public :skill_can_use?
end


class Game_Actor < Game_Battler
 include KGC_Game_Actor
 attr_writer :overdrive_type
 #--------------------------------------------------------------------------
 # * Setup
 #--------------------------------------------------------------------------
 alias setup_KGC_OverDrive setup
 def setup(actor_id)
# Executing the processing of the origin
setup_KGC_OverDrive(actor_id)
@overdrive, @overdrive_type = 0, 1
 end
 #--------------------------------------------------------------------------
 # * Acquisition of OverDrive gauge
 #--------------------------------------------------------------------------
 def overdrive
@overdrive = 0 if @overdrive == nil
return @overdrive
 end
 #--------------------------------------------------------------------------
 # * Operation of OverDrive gauge
 #--------------------------------------------------------------------------
 def overdrive=(value)
@overdrive = [[value, 0].max, KGC::OD_GAUGE_MAX].min
 end
 #--------------------------------------------------------------------------
 # * Acquisition of OverDrive type
 #--------------------------------------------------------------------------
 def overdrive_type
@overdrive_type = 0 if @overdrive_type == nil
return @overdrive_type
end
 end


 #==========================================================================
====
 # ** Scene_Battle (Part 1)
 #==========================================================================
====
 class Scene_Battle
 #--------------------------------------------------------------------------
 # * Battle Ends
 #	 result : results (0:win 1:lose 2:escape)
 #--------------------------------------------------------------------------
 alias battle_end_KGC_OverDrive battle_end
 def battle_end(result)
case result
when 0 # Victory
  $game_party.actors.each { |actor|
  next unless actor.exist?
  #When drive type "victory" is, addition
  if actor.overdrive_type == 2
	actor.overdrive += KGC::OD_GAIN_RATE[2]
  end
  }
when 1 # Flight
  $game_party.actors.each { |actor|
  next unless actor.exist?
  # When drive type "flight" is, addition
  if actor.overdrive_type == 3
	actor.overdrive += KGC::OD_GAIN_RATE[3]
  end
  }
end
 # Defeat
 battle_end_KGC_OverDrive(result)
 end
end



#==============================================================================
# ** Scene_Battle (Part 4)
#==============================================================================

class Scene_Battle
 #--------------------------------------------------------------------------
 # * Frame Update (main phase step 2 : start action) (Edited)
 #--------------------------------------------------------------------------
 alias update_phase4_step2_KGC_OverDrive update_phase4_step2
 def update_phase4_step2(battler)
if battler.is_a?(Game_Actor)
  # Gauge increase decision
  case battler.overdrive_type
  when 4 # Lonely battle
	alone = true
	$game_party.actors.each { |actor|
  next if actor == battler
	# When the survivor is, it is not lonely
	if actor.exist?
	  alone = false
	  break
	end
	}
	od_up = alone ? KGC::OD_GAIN_RATE[4] : 0
  when 5 # When acting
	od_up = KGC::OD_GAIN_RATE[5]
  when 6 # Dying
	od_up = (battler.hp <= battler.maxhp / 4) ?
	KGC::OD_GAIN_RATE[6] : 0
  else
	od_up = 0
  end
  battler.overdrive += od_up
end
# Executing the processing of the origin
update_phase4_step2_KGC_OverDrive(battler)
 end
 #--------------------------------------------------------------------------
 # * Frame Update (main phase step 4 : animation for target) (Meter Edited)
 #--------------------------------------------------------------------------  
 alias update_phase4_step4_KGC_OverDrive update_phase4_step4
 def update_phase4_step4(battler) 
@status_window.refresh
update_phase4_step4_KGC_OverDrive(battler)
 end
end

#==============================================================================
# ** Window_BattleStatus
#==============================================================================

class Window_BattleStatus < Window_Base
 #--------------------------------------------------------------------------
 # * Add Overdrive Meters
 #--------------------------------------------------------------------------
 alias refresh_KGC_OverDrive refresh
 def refresh(number = 0)
if self.contents == nil
  self.contents = Bitmap.new(width - 32, height - 32)
end
if number == 0
  for i in 0...$game_party.actors.size
	draw_actor_od($game_party.actors[i], i * 160 + 4, 88, 120)
  end
else
  if $game_party.actors[number].is_a?(Game_Actor)
	draw_actor_od($game_party.actors[number], number * 160 + 4, 88, 120)
  end
end
refresh_KGC_OverDrive(number)
 end
 #--------------------------------------------------------------------------
 # * Opacity Fix
 #--------------------------------------------------------------------------
 alias update_KGC_OverDrive update
 def update
if $game_temp.battle_main_phase
  self.contents_opacity -= 4 if self.contents_opacity > 191
else
  self.contents_opacity += 4 if self.contents_opacity < 255
end
 end
 #--------------------------------------------------------------------------
 # * Draw Overdrive Meter
 #--------------------------------------------------------------------------
 def draw_actor_od(actor, x, y, width = 144)
rate = actor.overdrive.to_f / KGC::OD_GAUGE_MAX
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
grade1 = 1
grade2 = 0
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
od = (width + plus_width) * actor.overdrive * rate_width / 100 /
  KGC::OD_GAUGE_MAX
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, od, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
 end
end
#==============================================================================
# ** KGC_Overdrive Ringer										  (09-05-2006)
#------------------------------------------------------------------------------
#	by DerVVulfman
#
#-------------------------------------------------------------------------------
#  A requested feature, this script checks whenever the overdrive bar is filled
#  and plays a pre-set sound effect accordingly. There isn't much to the script
#  and was fairly easy to write. It will work with both versions 1 and 2 of the
#  KGC_Overdrive script that I've posted,  and will probably work with the ori-
#  ginal version of KGC_Overdrive before it was edited by Minkoff.
#  
#==============================================================================



#============================================================================== 
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================
class Scene_Battle
 
 # Overdrive gauge maximum (same value as in KGC_OverDrive Script).
 OD_GAUGE_MAX = 500
 
 #--------------------------------------------------------------------------
 # * Full OD Gauge SE
 #--------------------------------------------------------------------------
 def fullod_se
Audio.se_play("Audio/SE/015-jump01", 100, 100)
 end
 #--------------------------------------------------------------------------
 # * Frame renewal (OD gauge renewal phase)
 #--------------------------------------------------------------------------
 alias update_phase0_overring update_phase0
 def update_phase0
# Call the original def from RTAB
update_phase0_overring
# Go through the Actors
$game_party.actors.each { |actor|
  # Only perform if the actor exists
  next unless actor.exist?
  # When the Overdrive bar is set to zero,
  # Reset the Overdrive Ringer to false
  if actor.overdrive == 0
	actor.overdrive_ring = false
  end
  # When the Overdrive Ringer hasn't rung
  if actor.overdrive_ring == false
	# But the Overdrive Bar is filled
	if actor.overdrive == OD_GAUGE_MAX 
	  # Play the Overdrive Sound Effect
	  fullod_se
	  # And Set the Overdrive Ringer to true
	  actor.overdrive_ring = true
	end
  end
  }
 end
end

 

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================
class Game_Actor < Game_Battler
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
  attr_accessor :overdrive_ring
 #--------------------------------------------------------------------------
 # * Setup
 #--------------------------------------------------------------------------
 alias setup_KGC_OverRing setup
 def setup(actor_id)
# Executing the processing of the origin
setup_KGC_OverRing(actor_id)
@overdrive_ring = false
 end
end

never_land · June 24, 2009

anche a me servirebbe

qualcuno lo può tradurre, nn capisco nulla di cm settare

Sign In

Cerco questi 3 script

Question

Squall_Leonheart

Link to comment

Share on other sites

7 answers to this question

Recommended Posts

bombolo

Link to comment

Share on other sites

MasterSion

Link to comment

Share on other sites

Narutofan95

Link to comment

Share on other sites

Amos_MHF

Link to comment

Share on other sites

Squall_Leonheart

Link to comment

Share on other sites

Squall_Leonheart

Link to comment

Share on other sites

never_land

Link to comment

Share on other sites

Create an account or sign in to comment

Create an account

Sign in

Browse

Activity