metaldrack

April 17, 2008

io non riesco a copiarlo lo script mi esce solo su un rigo... potete postarlo "meglio"...

scusa ma non stò al pc da moooolto tempo.....e quindi non sono entrato più su rpg2s....

comunque scusate,pensavo di averlo separato bene....

l'errore del rigo a me non lo dà..ma quando carico la partita mi dà uno strano errore.....

February 12, 2008

Mog Basic Menu Plus

Descrizione

questo script è stato creato da Moghunter e aggiunge voci extra al menu tipo il nome della mappa

Autore

Moghunter

Istruzioni per l'uso

##################################################
# Mog Basic Menu Plus V 1.0                      #
##################################################
# By Moghunter
# [url="http://www.atelier-rgss.com"]http://www.atelier-rgss.com[/url]
##################################################
#Menu padrão VX com adição de alguns extras, neste 
#script você poderá trabalhar em cima dele e adaptá-lo 
#facilmente ao seu jogo.
#-------------------------------------------------
##############
# Game_Actor #
##############
class Game_Actor < Game_Battler
def now_exp
return @exp - @exp_list[@level]
end
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end
###############
# Window_Base #
###############
class Window_Base < Window  
 def draw_actor_level_menu(actor, x, y)
   self.contents.font.color = system_color
   self.contents.draw_text(x, y, 32, WLH, Vocab::level_a)
   self.contents.font.color = normal_color
   self.contents.draw_text(x + 16, y, 24, WLH, actor.level, 2)
 end  
 def draw_actor_class_menu(actor, x, y)
   self.contents.font.color = normal_color
   self.contents.draw_text(x, y, 85, WLH, actor.class.name)
 end    
def exp_gauge_color1
   return text_color(30)
 end
 def exp_gauge_color2
   return text_color(31)
 end  
def draw_actor_exp_meter(actor, x, y, width = 100)  
 if actor.next_exp != 0
 exp = actor.now_exp
 else
 exp = 1
 end
   gw = width * exp / [actor.next_exp, 1].max
   gc1 = exp_gauge_color1
   gc2 = exp_gauge_color2
   self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
   self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
   self.contents.font.color = system_color
   self.contents.draw_text(x, y, 30, WLH, "Exp")    
   self.contents.font.color = normal_color
   xr = x + width
   self.contents.draw_text(xr - 60, y, 60, WLH,  actor.next_rest_exp_s, 2)    
end
end
#####################
# Window_MenuStatus #
#####################
class Window_MenuStatus < Window_Selectable
 def initialize(x, y)
   super(x, y, 384, 416)
   refresh
   self.active = false
   self.index = -1
 end
 def refresh
   self.contents.clear
   @item_max = $game_party.members.size
   for actor in $game_party.members
     draw_actor_face(actor, 2, actor.index * 96 + 2, 92)
     x = 104
     y = actor.index * 96 + WLH / 2
     draw_actor_name(actor, x, y)
     draw_actor_class_menu(actor, x + 120, y)
     draw_actor_level_menu(actor, x + 200, y)
     draw_actor_state(actor, x, y + WLH * 2)
     draw_actor_hp(actor, x + 120, y + WLH * 1)
     draw_actor_mp(actor, x + 120, y + WLH * 2)
     draw_actor_exp_meter(actor, x , y + WLH * 1)
   end
 end
 def update_cursor
   if @index < 0               
     self.cursor_rect.empty
   elsif @index < @item_max   
     self.cursor_rect.set(0, @index * 96, contents.width, 96)
   elsif @index >= 100         
     self.cursor_rect.set(0, (@index - 100) * 96, contents.width, 96)
   else                     
     self.cursor_rect.set(0, 0, contents.width, @item_max * 96)
   end
 end
end
############
# Game_Map #
############
class Game_Map
attr_reader   :map_id  
def mpname
$mpname = load_data("Data/MapInfos.rvdata") 
$mpname[@map_id].name
end
end
###############
# Window_Time #
###############
class Window_Mapname < Window_Base
 def initialize(x, y)
   super(x, y, 160, WLH + 64)
   refresh
 end  
def refresh
   self.contents.clear
   self.contents.font.color = system_color
   self.contents.draw_text(4, 0, 120, 32, "Location")
   self.contents.font.color = normal_color
   self.contents.draw_text(4, 32, 120, 32, $game_map.mpname.to_s, 2)
end
end
###############
# Window_Time #
###############
class Window_Time < Window_Base
 def initialize(x, y)
   super(x, y, 160, WLH + 64)
   refresh
 end
 def refresh
   self.contents.clear
   self.contents.font.color = system_color
   self.contents.draw_text(4, 0, 120, 32, "Play Time")
   @total_sec = Graphics.frame_count / Graphics.frame_rate
   hour = @total_sec / 60 / 60
   min = @total_sec / 60 % 60
   sec = @total_sec % 60
   text = sprintf("%02d:%02d:%02d", hour, min, sec)
   self.contents.font.color = normal_color
   self.contents.draw_text(4, 32, 120, 32, text, 2)
end
 def update
   super
   if Graphics.frame_count / Graphics.frame_rate != @total_sec
     refresh
   end
 end
end
##############
# Scene_Menu #
##############
class Scene_Menu   
 def main
   start                         
   perform_transition            
   Input.update                 
   loop do
     Graphics.update            
     Input.update              
     update                      
     break if $scene != self      
   end
   Graphics.update
   pre_terminate             
   Graphics.freeze               
   terminate                   
 end  
 def initialize(menu_index = 0)
   @menu_index = menu_index
 end  
 def create_menu_background
   @menuback_sprite = Sprite.new
   @menuback_sprite.bitmap = $game_temp.background_bitmap
   @menuback_sprite.color.set(16, 16, 16, 128)
   update_menu_background
 end  
 def create_menu_background
   @menuback_sprite = Sprite.new
   @menuback_sprite.bitmap = $game_temp.background_bitmap
   @menuback_sprite.color.set(16, 16, 16, 128)
   update_menu_background
 end
 def dispose_menu_background
   @menuback_sprite.dispose
 end
 def update_menu_background
 end  
 def perform_transition
    Graphics.transition(10)
 end
 def start
   create_menu_background
   create_command_window
   @gold_window = Window_Gold.new(0, 360)
   @status_window = Window_MenuStatus.new(160, 0)
   @playtime_window = Window_Time .new(0, 270)
   @mapname_window = Window_Mapname.new(0, 178)
   @status_window.openness = 0
   @playtime_window.openness = 0
   @mapname_window.openness = 0
   @gold_window.openness = 0
   @status_window.open
   @playtime_window.open
   @mapname_window.open
   @gold_window.open
 end
 def pre_terminate
   @status_window.close
   @playtime_window.close
   @mapname_window.close
   @gold_window.close
   @command_window.close
   begin
   @status_window.update
   @playtime_window.update
   @mapname_window.update
   @gold_window.update
   @command_window.update
   Graphics.update
   end until @status_window.openness == 0
 end  
 def terminate
   dispose_menu_background
   @command_window.dispose
   @gold_window.dispose
   @status_window.dispose
   @playtime_window.dispose
   @mapname_window.dispose
 end
 def update
   update_menu_background
   @command_window.update
   @gold_window.update
   @status_window.update
   @mapname_window.update
   @playtime_window.update
   if @command_window.active
     update_command_selection
   elsif @status_window.active
     update_actor_selection
   end
 end
 def create_command_window
   s1 = Vocab::item
   s2 = Vocab::skill
   s3 = Vocab::equip
   s4 = Vocab::status
   s5 = Vocab::save
   s6 = Vocab::game_end
   @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
   @command_window.index = @menu_index
   @command_window.openness = 0
   @command_window.open
   if $game_party.members.size == 0           
     @command_window.draw_item(0, false)     
     @command_window.draw_item(1, false)     
     @command_window.draw_item(2, false)      
     @command_window.draw_item(3, false)    
   end
   if $game_system.save_disabled              
     @command_window.draw_item(4, false)     
   end
 end
 def update_command_selection
   if Input.trigger?(Input::B)
     Sound.play_cancel
     $scene = Scene_Map.new
   elsif Input.trigger?(Input::C)
     if $game_party.members.size == 0 and @command_window.index < 4
       Sound.play_buzzer
       return
     elsif $game_system.save_disabled and @command_window.index == 4
       Sound.play_buzzer
       return
     end
     Sound.play_decision
     case @command_window.index
     when 0      
       $scene = Scene_Item.new
     when 1,2,3   
       start_actor_selection
     when 4       
       $scene = Scene_File.new(true, false, false)
     when 5     
       $scene = Scene_End.new
     end
   end
 end
 def start_actor_selection
   @command_window.active = false
   @status_window.active = true
   if $game_party.last_actor_index < @status_window.item_max
     @status_window.index = $game_party.last_actor_index
   else
     @status_window.index = 0
   end
 end
 def end_actor_selection
   @command_window.active = true
   @status_window.active = false
   @status_window.index = -1
 end
 def update_actor_selection
   if Input.trigger?(Input::B)
     Sound.play_cancel
     end_actor_selection
   elsif Input.trigger?(Input::C)
     $game_party.last_actor_index = @status_window.index
     Sound.play_decision
     case @command_window.index
     when 1 
       $scene = Scene_Skill.new(@status_window.index)
     when 2   
       $scene = Scene_Equip.new(@status_window.index)
     when 3  
       $scene = Scene_Status.new(@status_window.index)
     end
   end
 end
end
$mogscript = {} if $mogscript == nil
$mogscript["basic_menu_plus"] = true

February 12, 2008

Caterpillar

Descrizione

questo è il caterpillar per rpg maker vx...a me non funziona(mi dà errore quando carico la partita)

ah,inoltre l'adattamento non è fatto da me(ma no???già è tanto se stò imparando il c e il c#)ma probabilmente da Diedrupo(non ne sono sicuro...quindi ditemelo se sbaglio)inoltre lo ha postato male(io lo script lo ho cancellato,l'ho preso da un sito,ma penso ke sia spoiler se lo dico...)quindi dovete fare copia e incolla con word ovviamente dovete creare una classe sopra main e chiamarla come vi pare

EDIT:ho proveduto io al risistemamento dello script quindi prendetelo e mettetelo direttamente su rpg maker vx

Ecco qui il caterpillar corretto

Autore

creato da: Trickster's

adattato da: Diedrupo

class Game_Player
#--------------------------------------------------------------------------
# * Move Down
# turn_enabled : a flag permits direction change on that spot
#--------------------------------------------------------------------------
def move_down(turn_enabled = true)
super(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Left
# turn_enabled : a flag permits direction change on that spot
#--------------------------------------------------------------------------
def move_left(turn_enabled = true)
super(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Right
# turn_enabled : a flag permits direction change on that spot
#--------------------------------------------------------------------------
def move_right(turn_enabled = true)
super(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move up
# turn_enabled : a flag permits direction change on that spot
#--------------------------------------------------------------------------
def move_up(turn_enabled = true)
super(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Lower Left
#--------------------------------------------------------------------------
def move_lower_left
super
end
#--------------------------------------------------------------------------
# * Move Lower Right
#--------------------------------------------------------------------------
def move_lower_right
super
end
#--------------------------------------------------------------------------
# * Move Upper Left
#--------------------------------------------------------------------------
def move_upper_left
super
end
#--------------------------------------------------------------------------
# * Move Upper Right
#--------------------------------------------------------------------------
def move_upper_right
super
end
end

class Game_Follower < Game_Character
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :actor
attr_accessor :move_speed
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(actor)
super()
@through = true
@actor = actor
end
#--------------------------------------------------------------------------
# * Set Actor
#--------------------------------------------------------------------------
def actor=(actor)
@actor = actor
setup
end
#--------------------------------------------------------------------------
# * Setup
#--------------------------------------------------------------------------
def setup
if @actor != nil
@character_name = $game_actors[@actor].character_name
@character_index = $game_actors[@actor].character_index
else
@character_name = ""
@character_index = 0
end
@opacity = 255
@blend_type = 0
@priority_type = 0
end

#--------------------------------------------------------------------------
# * Screen Z
#--------------------------------------------------------------------------
def screen_z
if $game_player.x == @x and $game_player.y == @y
return $game_player.screen_z - 1
end
super
end
#--------------------------------------------------------------------------
# * Same Position Starting Determinant (Disabled)
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers)
result = false
return result
end
#--------------------------------------------------------------------------
# * Front Envent Starting Determinant (Disabled)
#--------------------------------------------------------------------------
def check_event_trigger_there(triggers)
result = false
return result
end
#--------------------------------------------------------------------------
# * Touch Event Starting Determinant (Disabled)
#--------------------------------------------------------------------------
def check_event_trigger_touch(x, y)
result = false
return result
end
end

class Spriteset_Map
alias_method :spriteset_map_create_characters, :create_characters
def create_characters
spriteset_map_create_characters
$game_party.followers.each do |char|
@character_sprites << Sprite_Character.new(@viewport1, char)
end
end
end

class Game_Party
#--------------------------------------------------------------------------
# * Constants
#--------------------------------------------------------------------------
MAX_SIZE = 8
CATERPILLAR = 2
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :followers
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_party_initialize, :initialize
def initialize
trick_caterpillar_party_initialize
@followers = Array.new(MAX_SIZE - 1) {Game_Follower.new(nil)}
@move_list = []
end
#--------------------------------------------------------------------------
# * Update Followers
#--------------------------------------------------------------------------
def update_followers
flag = $game_player.transparent || $game_switches[CATERPILLAR]
@followers.each_with_index do |char, i|
char.actor = @actors[i + 1]
char.move_speed = $game_player.move_speed
if $game_player.dash?
char.move_speed += 1
end
char.update
char.transparent = flag
end
end
#--------------------------------------------------------------------------
# * Move To Party
#--------------------------------------------------------------------------
def moveto_party(x, y)
@followers.each {|char| char.moveto(x, y)}
@move_list.clear
end
#--------------------------------------------------------------------------
# * Move Party
#--------------------------------------------------------------------------
def move_party
@move_list.each_index do |i|
if @followers[i] == nil
@move_list[i...@move_list.size] = nil
next
end
case @move_list[i].type
when 2
@followers[i].move_down(*@move_list[i].args)
when 4
@followers[i].move_left(*@move_list[i].args)
when 6
@followers[i].move_right(*@move_list[i].args)
when 8
@followers[i].move_up(*@move_list[i].args)
when 1
@followers[i].move_lower_left
when 3
@followers[i].move_lower_right
when 7
@followers[i].move_upper_left
when 9
@followers[i].move_upper_right
when 5
@followers[i].jump(*@move_list[i].args)
end
end
end
#--------------------------------------------------------------------------
# * Add Move List
#--------------------------------------------------------------------------
def update_move(type, *args)
move_party
@move_list.unshift(Game_MoveListElement.new(type, args))
end
end

class Game_MoveListElement
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(type, args)
@type = type
@args = args
end
#--------------------------------------------------------------------------
# * Type
#--------------------------------------------------------------------------
def type
return @type
end
#--------------------------------------------------------------------------
# * Args
#--------------------------------------------------------------------------
def args
return @args
end
end

class Game_Player
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :move_speed

#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_update, :update
def update
$game_party.update_followers
trick_caterpillar_player_update
end
#--------------------------------------------------------------------------
# * Moveto
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_moveto, :moveto
def moveto(x, y)
$game_party.moveto_party(x, y)
trick_caterpillar_player_moveto(x, y)
end
#--------------------------------------------------------------------------
# * Move Down
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_down, :move_down
def move_down(turn_enabled = true)
if passable?(@x, @y+1)
$game_party.update_move(2, turn_enabled)
end
trick_caterpillar_player_move_down(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Left
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_left, :move_left
def move_left(turn_enabled = true)
if passable?(@x-1, @y)
$game_party.update_move(4, turn_enabled)
end
trick_caterpillar_player_move_left(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Right
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_right, :move_right
def move_right(turn_enabled = true)
if passable?(@x+1, @y)
$game_party.update_move(6, turn_enabled)
end
trick_caterpillar_player_move_right(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Up
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_up, :move_up
def move_up(turn_enabled = true)
if passable?(@x, @y-1)
$game_party.update_move(8, turn_enabled)
end
trick_caterpillar_player_move_up(turn_enabled)
end
#--------------------------------------------------------------------------
# * Move Lower Left
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_lower_left, :move_lower_left
def move_lower_left
if passable?(@x - 1, @y) and passable?(@x, @y + 1)
$game_party.update_move(1)
end
trick_caterpillar_player_move_lower_left
end
#--------------------------------------------------------------------------
# * Move Lower Right
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_lower_right, :move_lower_right
def move_lower_right
if passable?(@x + 1, @y) and passable?(@x, @y + 1)
$game_party.update_move(3)
end
trick_caterpillar_player_move_lower_right
end
#--------------------------------------------------------------------------
# * Move Upper Left
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_upper_left, :move_upper_left
def move_upper_left
if passable?(@x - 1, @y) and passable?(@x, @y - 1)
$game_party.update_move(7)
end
trick_caterpillar_player_move_upper_left
end
#--------------------------------------------------------------------------
# * Move Upper Right
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_move_upper_right, :move_upper_right
def move_upper_right
if passable?(@x + 1, @y) and passable?(@x, @y - 1)
$game_party.update_move(9)
end
trick_caterpillar_player_move_upper_right
end
#--------------------------------------------------------------------------
# * Jump
#--------------------------------------------------------------------------
alias_method :trick_caterpillar_player_jump, :jump
def jump(x_plus, y_plus)
new_x = @x + x_plus
new_y = @y + y_plus
if (x_plus == 0 and y_plus == 0) or passable?(new_x, new_y)
$game_party.update_move(5, x_plus, y_plus)
end
trick_caterpillar_player_jump(x_plus, y_plus)
end
end

Nuovo_Documento_di_Microsoft_Word.doc

February 12, 2008

Cambio Party

Descrizione

sò che questo script non interesserà a nessuno,poichè si può fare la stessa cosa ad eventi,comunque ho trovato questo script per vx e lo posto se ho sbagliato qualcosa ditemelo che è il primo script che posto

Autore

Blizzard

Istruzioni per l'uso

creare una nuova classe sopra main e chiamarla come vi pare

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
=:=:=:=:=
:=:=:=:=
# Easy Party Switcher by Blizzard
# Version 2.11b
# Type: Party Changing System
# Date: 21.05.2006
# Date v1.1: 25.05.2006
# Date v1.2b: 27.05.2006
# Date v1.5b: 3.11.2006
# Date v1.51b: 29.11.2006
# Date v1.52b: 6.12.2006
# Date v1.7b: 23.2.2007
# Date v1.8b: 30.4.2007
# Date v2.0b: 7.8.2007
# Date v2.1b: 24.8.2007
# Date v2.11b: 24.9.2007
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Special Thanks to:
# 
#   Zeriab for pointing out a few glitches and shortening the code in an
#   earlier version. =D
# 
# 
# IMPORTANT NOTE:
# 
#   Be sure to set the MAX_PARTY to the maximum size of your party. There is
#   already a preconfiguration of 4.
# 
# 
# Compatibility:
# 
#   98% compatible with SDK v1.x. 90% compatible with SDK 2.x. Can cause
#   incompatibility issued with other Party Change Systems. WILL corrupt your
#   old savegames. 
# 
# 
# Features:
# 
#   - set party members for "not _available" (shown transparent in the reserve)
#   - remove party members from the reserve list ("disabled_for_party")
#   - set party members, who MUST be in the party (shown transparent in the
#     current party, "must_be_in_party")
#   - set up forced positions for party members
#   - set up forced party size
#   - option either to wipe the party (for multi-party use) or only remove
#     every member (except 1) from the party.
#   - easy to use and easy to switch party members
#   - also supports small parties (2 or 3 members) and large parties (5 or
#     more)
#   - uses facesets optionally
# 
# v1.5b:
#   - better, shorter and more efficient code (less memory use, less CPU use)
#   - fixed potential bugs
# 
# v1.7b:
#   - improved coding
#   - facesets now optional
#   - no extra bitmap files needed anymore
#   - works now with Tons of Add-ons
# 
# v1.8b:
#   - added "forced position"
#   - added "forced party size"
# 
# v2.0b:
#   - fixed the bug where you could empty the party... again...
#   - fixed the bug that appeared when you pressed SHIFT
#   - added option to allow an empty party
#   - added "EXP for party members in reserve" option
#   - made the forced_size for party work more convenient
#   - improved coding
#   - slightly decreased lag
# 
# v2.1b:
#   - fixed a bug
#   - improved coding
#   - rewritten conditions using classic syntax to avoid RGSS conditioning bug
#   - now can serve as enhancement for CP Debug System
# 
# v2.11b:
#   - improved coding and performance
# 
# 
# How to use:
# 
#   To call this script, make a "Call script" command in an event.
# 
#   1. Syntax: $scene = Scene_PartySwitcher.new
#      No extra feature will be applied and you can switch the party as you
#      wish.
# 
#   2. Syntax: $scene = Scene_PartySwitcher.new(XXX)
#      You can replace XXX for 1 to remove all party members except one (either
#      one, who must be in the party or a random one), or replace XXX with 2,
#      to cause a wipe party. Wiping a party will disable the of the current
#      members and a NEW party of the remaining members must be formed. If you
#      replace it with 3, the current party configuration will be stored for a
#      later fast switch-back. If XXX is 10, all actors will be available for
#      party switching no matter if the are "not_available" or
#      "disabled_for_party". This feature if used by the CP Debug System. No
#      faceset will be used in this case for a more convenient working.
# 
#   3. Syntax: $scene = Scene_PartySwitcher.new(XXX, 1)
#      You can use the XXX as described above or just set it to 0 to disable
#      it. Also the "1" in the syntax will reset any disabled_for_party and is
#      made to be used after multi-party use.
# 
#   4. Syntax: $scene = Scene_PartySwitcher.new(XXX, YYY, ZZZ)
#      You can replace ZZZ with 1 to replace the party with a stored one AND
#      store the current or replace it with 2 to replace the party with a
#      stored one, but without storing the current. USE THIS ONLY IF YOU ASSUME
#      TO HAVE A STORED PARTY READY! You can simply test if there is a store
#      party by putting this code into the conditional branch script:
# 
#      $game_system.stored_party != nil
# 
#      This syntax will not open the Party Switcher and it will override the
#      commands XXX and YYY, so you can replace these with any number.
# 
#   Character faces go into the "Characters" folder and they have the same name
#   as the character spritesets have with _face added
# 
#   Example:
# 
#     sprite - Marlen.png
#     face   - Marlen_face.png
# 
#   Other syntaxes:
#     $game_actors[iD].not_available = true/false
#     $game_actors[iD].disabled_for_party = true/false
#     $game_actors[iD].must_be_in_party = true/false
#     $game_actors[iD].forced_position = nil/0/1/2/...
#   OR
#     $game_party.actors[POS].not_available = true/false
#     $game_party.actors[POS].disabled_for_party = true/false
#     $game_party.actors[POS].must_be_in_party = true/false
#     $game_party.actors[POS].forced_position = nil/0/1/2/...
# 
#   ID  - the actor's ID in the database
#   POS - the actor's position in the party (STARTS FROM 0, not 1!)
# 
#   not_available
#   - will disable the possibility of an already unlocked character to be in
#     the current party
# 
#   disabled_for_party
#   - will cause the character NOT to appear in the party switch screen at all
# 
#   must_be_in_party
#   - will cause the character to be automatically moved into the current party
#     and he also cannot be put in the reserve
# 
#   forced_position
#   - will enforce the player to be at a specific position in the party, set
#     this value to nil to disable this feature, use it in combination with
#     must_be_in_party and $game_party.forced_size or you might experience
#     bugs,
# 
#   $game_party.forced_size = nil/0/1/2/...
# 
#   Using this syntax will enforce a specific party size. The EPS won't exit
#   until this size is filled up or there are no more in the reserve. EPS will
#   automatically "correct" this number if there are not enough characters in
#   the reserve to fill up a party of forced_size. Set this value to nil to
#   disable the size requirement. Note that the actor DO NOT HAVE TO be set in
#   normal order without any empty position like in version 1.x.
# 
# 
# Additional note:
# 
#   For your own sake, do not apply the attribute "must_be_in_party" to a
#   character at the same time with "not_available" or "disabled_for_party" as
#   this WILL disrupt your party and party switch system. Use "forced_position"
#   together with "must_be_in_party" to avoid bugs. Be careful when using
#   "forced_position" with "$game_party.forced_size". Add actors at the very
#   end to be sure the player can't put others after them if the "forced_size"
#   is smaller than the maximum party size.
# 
# 
# If you find any bugs, please report them here:
# [url="http://www.chaosproject.co.nr"]http://www.chaosproject.co.nr[/url]
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# START Conficuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

# how many party members do you use
MAX_PARTY = 4
# set to true to use facesets instead of spritesets
FACESETS = false
# allows a party with 0 members
ALLOW_EMPTY_PARTY = false
# gives all other characters EXP (specify in %)
EXP_RESERVE = 50
# gives "not available" characters EXP (specify in %)
EXP_NOT_AVAILABLE = 0
# gives "disabled for party" characters EXP (specify in %)
EXP_DISABLED_FOR_PARTY = 0

#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# END Conficuration
#::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

# recognition variable for plug-ins
$easy_party_switcher = true

#==============================================================================
# Game_Actor
#==============================================================================

class Game_Actor < Game_Battler

attr_accessor :must_be_in_party
attr_accessor :disabled_for_party
attr_accessor :not_available
attr_accessor :forced_position

alias setup_eps_later setup
def setup(actor_id)
  setup_eps_later(actor_id)
  @must_be_in_party = @disabled_for_party = @not_available = false
end

end

#==============================================================================
# Game_System
#==============================================================================

class Game_System

attr_accessor :stored_party

end

#==============================================================================
# Game_Party
#==============================================================================

class Game_Party

attr_accessor :actors
attr_accessor :forced_size

def any_forced_position
  return (@actors.any? {|actor| actor != nil && actor.forced_position != nil})
end

end

#==============================================================================
# Window_Base
#==============================================================================

class Window_Base

alias draw_actor_graphic_eps_later draw_actor_graphic
def draw_actor_graphic(actor, x, y)
  if actor != nil && actor.character_name != ''
    classes = [Window_Current, Window_Reserve, Window_HelpStatus]
    if FACESETS && !$all_available && classes.include?(self.class)
      draw_actor_face_eps(actor, x, y)
    else
      if classes.include?(self.class)
        bitmap = RPG::Cache.character(actor.character_name, actor.character_hue)
        x += bitmap.width / 8 + 24
        y += bitmap.height / 4 + 16
      end
      draw_actor_graphic_eps_later(actor, x, y)
    end
  end
end

def draw_actor_face_eps(actor, x, y)
  if $tons_version == nil || $tons_version < 3.71 || !FACE_HUE
    hue = 0
  else
    hue = actor.character_hue
  end
  bitmap = RPG::Cache.character("#{actor.character_name}_face", hue)
  src_rect = Rect.new(0, 0, bitmap.width, bitmap.height)
  if actor.not_available || actor.must_be_in_party
    self.contents.blt(x, y, bitmap, src_rect, 128)
  else
    self.contents.blt(x, y, bitmap, src_rect)
  end
end

end

#==============================================================================
# Window_BattleResult
#==============================================================================

class Window_BattleResult

attr_reader :exp

end

#==============================================================================
# Window_Current
#==============================================================================

class Window_Current < Window_Selectable

def initialize
  super(0, 0, 240 + 32, (MAX_PARTY > 4 ? 480 : MAX_PARTY * 120))
  self.contents = Bitmap.new(width - 32, 448 + (MAX_PARTY-4) * 120)
  @item_max = MAX_PARTY
  if $fontface != nil
    self.contents.font.name = $fontface
  elsif $defaultfonttype != nil
    self.contents.font.name = $defaultfonttype
  end
  self.contents.font.size = 24
  refresh
  self.active, self.index = false, -1
end

def refresh
  self.contents.clear
  $game_party.actors.each_index {|i|
      if $game_party.actors[i] != nil
        draw_actor_graphic($game_party.actors[i], 4, i*120+4)
        draw_actor_name($game_party.actors[i], 152, i*120-4)
        draw_actor_level($game_party.actors[i], 88, i*120-4)
        draw_actor_hp($game_party.actors[i], 88, i*120+28)
        draw_actor_sp($game_party.actors[i], 88, i*120+60)
      end}
end

def setactor(index_1, index_2)
  $game_party.actors[index_2], $game_party.actors[index_1] =
      $game_party.actors[index_1], $game_party.actors[index_2]
  refresh
end

def getactor(index)
  return $game_party.actors[index]
end

def update_cursor_rect
  if @index < 0
    self.cursor_rect.empty
    return
  end
  row = @index / @column_max
  self.top_row = row if row < self.top_row
  self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
  y = (@index / @column_max) * 120 - self.oy
  self.cursor_rect.set(0, y, self.width - 32, 88)
end

def clone_cursor
  row = @index / @column_max
  self.top_row = row if row < self.top_row
  self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
  y = (@index / @column_max) * 120
  src_rect = Rect.new(0, 0, self.width, 88)
  bitmap = Bitmap.new(self.width-32, 88)
  bitmap.fill_rect(0, 0, self.width-32, 88, Color.new(255, 255, 255, 192))
  bitmap.fill_rect(2, 2, self.width-36, 84, Color.new(255, 255, 255, 80))
  self.contents.blt(0, y, bitmap, src_rect, 192)
end

def top_row
  return self.oy / 116
end

def top_row=(row)
  self.oy = (row % row_max) * 120
end

def page_row_max
  return (self.height / 120)
end

end

#==============================================================================
# Window_Reserve
#==============================================================================

class Window_Reserve < Window_Selectable

attr_reader :actors

def initialize
  super(0, 0, 368, 320)
  setup
  @column_max, rows = 3, @item_max / @column_max
  self.contents = Bitmap.new(width - 32, (rows >= 3 ? rows * 96 : height - 32))
  if $fontface != nil
    self.contents.font.name = $fontface
  elsif $defaultfonttype != nil
    self.contents.font.name = $defaultfonttype
  end
  self.contents.font.size = 24
  self.active, self.index = false, -1
  refresh
end

def setup
  @actors = []
  (1...$data_actors.size).each {|i|
      unless $game_party.actors.include?($game_actors[i]) ||
          $game_actors[i].disabled_for_party && !$all_available
        @actors.push($game_actors[i])
      end}
  @item_max = (@actors.size + $game_party.actors.size + 3) / 3 * 3
end

def refresh
  self.contents.clear
  @actors.each_index {|i| draw_actor_graphic(@actors[i], i%3*112+16, i/3*96+8)}
end

def getactor(index)
  return @actors[index]
end

def get_number
  return (@actors.find_all {|actor| actor != nil}).size if $all_available
  return (@actors.find_all {|actor| actor != nil && !actor.not_available}).size
end

def setactor(index_1, index_2)
  @actors[index_1], @actors[index_2] = @actors[index_2], @actors[index_1]
  refresh
end

def setparty(index_1, index_2)
  @actors[index_1], $game_party.actors[index_2] =
      $game_party.actors[index_2], @actors[index_1]
  refresh
end

def update_cursor_rect
  if @index < 0
    self.cursor_rect.empty
    return
  end
  row = @index / @column_max
  self.top_row = row if row < self.top_row
  self.top_row = row - (page_row_max-1) if row > top_row + (page_row_max-1)
  x, y = (@index % @column_max)*112 + 8, (@index / @column_max)*96 - self.oy
  self.cursor_rect.set(x, y, 96, 96)
end

def clone_cursor
  row = @index / @column_max
  self.top_row = row if row < self.top_row
  self.top_row = row - (page_row_max - 1) if row > top_row + (page_row_max - 1)
  x, y = (@index % @column_max) * 112 + 8, (@index / @column_max) * 96
  src_rect = Rect.new(0, 0, 96, 96)
  bitmap = Bitmap.new(96, 96)
  bitmap.fill_rect(0, 0, 96, 96, Color.new(255, 255, 255, 192))
  bitmap.fill_rect(2, 2, 92, 92, Color.new(255, 255, 255, 80))
  self.contents.blt(x, y, bitmap, src_rect, 192)
end

def top_row
  return self.oy / 96
end

def top_row=(row)
  row = row % row_max
  self.oy = row * 96
end

def page_row_max
  return (self.height - 32) / 96
end

end

#==============================================================================
# Window_HelpStatus
#==============================================================================

class Window_HelpStatus < Window_Base

def initialize(gotactor)
  super(0, 0, 400 - 32, 160)
  self.contents = Bitmap.new(width - 32, height - 32)
  if $fontface != nil
    self.contents.font.name = $fontface
  elsif $defaultfonttype != nil
    self.contents.font.name = $defaultfonttype
  end
  self.contents.font.size = 24
  refresh(gotactor)
  self.active = false
end

def refresh(actor)
  self.contents.clear
  if actor != nil
    self.contents.font.color = normal_color
    if actor.not_available && !$all_available
      self.contents.draw_text(8, 0, 160, 32, 'not available', 0)
    end
    draw_actor_graphic(actor, 0, 40)
    draw_actor_name(actor, 160, 32)
    draw_actor_level(actor, 96, 32)
    draw_actor_hp(actor, 96, 64)
    draw_actor_sp(actor, 96, 96)
  end
end

end

#==============================================================================
# Window_Warning
#==============================================================================

class Window_Warning < Window_Base

def initialize(mode, members)
  super(0, 0, 320, 96)
  self.contents = Bitmap.new(width - 32, height - 32)
  if $fontface != nil
    self.contents.font.name = $fontface
  elsif $defaultfonttype != nil
    self.contents.font.name = $defaultfonttype
  end
  self.contents.font.size = 24
  self.x, self.y, self.z = 320 - width/2, 240 - height/2, 9999
  self.contents.font.color = normal_color
  if mode
    self.contents.draw_text(0, 0, 288, 32, 'You need a party', 1)
    num = [$game_party.forced_size, members + $game_party.actors.nitems].min
    self.contents.draw_text(0, 32, 288, 32, "of #{num} members!", 1)
  else
    self.contents.draw_text(0, 0, 288, 32, 'You cannot remove', 1)
    self.contents.draw_text(0, 32, 288, 32, 'the last party member!', 1)
  end
end

end

#==============================================================================
# Scene_PartySwitcher
#==============================================================================

class Scene_PartySwitcher

def initialize(wipe_party = 0, reset = 0, store = 0)
  @wipe_party, @store, @reset = store, reset, wipe_party
  @current_window_temp = @reserve_window_temp = 0
  @scene_flag, @temp_window = false, ''
end

def main
  if @store != 0
    swap_parties
    $scene = Scene_Map.new
    $game_player.refresh
    return
  end
  case @wipe_party
  when 1 then setup_forced_party
  when 2 then wipe_party
  when 3
    $game_system.stored_party = $game_party.actors
    wipe_party
  when 10 then $all_available = true
  end
  if @reset == 1
    (1...$data_actors.size).each {|i| $game_actors[i].not_available = false}
  end
  @current_window = Window_Current.new
  @current_window.index, @current_window.active = 0, true
  @reserve_window = Window_Reserve.new
  @reserve_window.x, @reserve_window.y = 272, 160
  @help_window = Window_HelpStatus.new(@reserve_window.getactor(0))
  @help_window.x = 240 + 32
  Graphics.transition
  loop do
    Graphics.update
    Input.update
    update
    break if $scene != self
  end
  Graphics.freeze
  [@current_window, @reserve_window, @help_window].each {|win| win.dispose}
  $game_party.actors.compact!
  $game_player.refresh
  $all_available = nil
end

def update
  check = @reserve_window.index
  if @reserve_window.active
    reserve_update
    @reserve_window.update
  end
  if check != @reserve_window.index
    if @reserve_window.active
      actor = @reserve_window.getactor(@reserve_window.index)
    elsif @current_window.active 
      actor = @reserve_window.getactor(@reserve_window_temp)
    end
    @help_window.refresh(actor) if ['', 'Current'].include?(@temp_window)
  end
  current_update if @current_window.active
  if Input.trigger?(Input::B)
    if @scene_flag
      $game_system.se_play($data_system.cancel_se)
      @scene_flag, @temp_window = false, ''
      if @reserve_window.active
        actor = @reserve_window.getactor(@reserve_window.index)
      elsif @current_window.active
        actor = @reserve_window.getactor(@reserve_window_temp)
      end
      @help_window.refresh(actor) if ['', 'Current'].include?(@temp_window)
      [@current_window, @reserve_window].each {|win| win.refresh}
      return
    end
    if $game_party.forced_size != nil &&
        ($game_party.forced_size < $game_party.actors.nitems ||
        ($game_party.forced_size > $game_party.actors.nitems &&
        @reserve_window.get_number != 0))
      $game_system.se_play($data_system.buzzer_se)
      warning(true)
      return
    end
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Map.new
  elsif Input.trigger?(Input::A)
    if $game_party.any_forced_position
      $game_system.se_play($data_system.buzzer_se)
    else
      $game_system.se_play($data_system.decision_se)
      $game_party.actors.compact! 
      @current_window.refresh
    end
  end
end
  
def current_update
  @current_window.update
  if Input.trigger?(Input::C)
    actor = @current_window.getactor(@current_window.index)
    if actor != nil && actor.forced_position != nil
      $game_system.se_play($data_system.buzzer_se)
    else
      if @scene_flag
        switch_members
      else
        $game_system.se_play($data_system.decision_se)
        @scene_flag, @temp_window = true, 'Current'
        @temp_actor_index = @current_window.index
        @current_window.clone_cursor
      end
    end
  elsif Input.trigger?(Input::RIGHT)
    $game_system.se_play($data_system.cursor_se)
    @current_window.active = false
    @reserve_window.active = true
    @current_window_temp = @current_window.index
    actor = @reserve_window.getactor(@reserve_window_temp)
    @current_window.index = -1
    @reserve_window.index = @reserve_window_temp
    @help_window.refresh(actor) unless @scene_flag
  end
end

def reserve_update
  if Input.trigger?(Input::C)
    if @scene_flag
      switch_members
    else
      $game_system.se_play($data_system.decision_se)
      @scene_flag, @temp_window = true, 'Reserve'
      @temp_actor_index = @reserve_window.index
      @reserve_window.clone_cursor
    end
  elsif @reserve_window.index % 3 == 0 && Input.repeat?(Input::LEFT)
    $game_system.se_play($data_system.cursor_se)
    @reserve_window.active = false
    @current_window.active = true
    @reserve_window_temp = @reserve_window.index
    @reserve_window.index = -1
    @current_window.index = @current_window_temp
  end
end

def switch_members
  if @temp_window == 'Reserve' && @reserve_window.active
    @reserve_window.setactor(@temp_actor_index, @reserve_window.index)
    actor = @reserve_window.getactor(@reserve_window.index)
    @help_window.refresh(actor)
  end
  if @temp_window == 'Current' && @current_window.active
    @current_window.setactor(@temp_actor_index, @current_window.index)
  end
  if @temp_window == 'Reserve' && @current_window.active
    actor1 = @current_window.getactor(@current_window.index)
    actor2 = @reserve_window.getactor(@temp_actor_index)
    if call_warning?(@current_window.index, actor2)
      if actor1 != nil && actor1.must_be_in_party
        $game_system.se_play($data_system.buzzer_se)
        @scene_flag, @temp_window = false, ''
        actor = @reserve_window.getactor(@reserve_window_temp)
        [@current_window, @reserve_window].each {|win| win.refresh}
        @help_window.refresh(actor)
        return
      end
      if actor2 != nil && actor2.not_available && !$all_available
        $game_system.se_play($data_system.buzzer_se)
        @scene_flag, @temp_window = false, ''
        actor = @reserve_window.getactor(@reserve_window_temp)
        [@current_window, @reserve_window].each {|win| win.refresh}
        @help_window.refresh(actor)
        return
      end
      @reserve_window.setparty(@temp_actor_index, @current_window.index)
      @current_window.refresh
      actor = @reserve_window.getactor(@reserve_window_temp)
      @help_window.refresh(actor)
    else
      warning
    end
  end
  if @temp_window == 'Current' && @reserve_window.active
    actor1 = @current_window.getactor(@temp_actor_index)
    actor2 = @reserve_window.getactor(@reserve_window.index)
    if call_warning?(@temp_actor_index, actor2)
      if actor1 != nil && actor1.must_be_in_party
        $game_system.se_play($data_system.buzzer_se)
        @scene_flag, @temp_window = false, ''
        actor = @reserve_window.getactor(@reserve_window.index)
        [@current_window, @reserve_window].each {|win| win.refresh}
        @help_window.refresh(actor)
        return
      end
      if actor2 != nil && actor2.not_available && !$all_available
        $game_system.se_play($data_system.buzzer_se)
        @scene_flag, @temp_window = false, ''
        actor = @reserve_window.getactor(@reserve_window.index)
        [@current_window, @reserve_window].each {|win| win.refresh}
        @help_window.refresh(actor)
        return
      end
      @reserve_window.setparty(@reserve_window.index, @temp_actor_index)
      @current_window.refresh
      actor = @reserve_window.getactor(@reserve_window.index)
      @help_window.refresh(actor)
    else
      warning
    end
  end
  $game_system.se_play($data_system.decision_se)
  @scene_flag, @temp_window = false, ''
end
  
def wipe_party
  $game_party.actors.each {|actor| actor.not_available = true if actor != nil}
  setup_forced_party(true)
  if $game_party.actors == []
    (1...$data_actors.size).each {|i|
        unless $game_actors[i].not_available ||
            $game_actors[i].disabled_for_party
          $game_party.actors.push($game_actors[i])
          return
        end}
  end
end

def setup_forced_party(flag = false)
  $game_party.actors, party = [], []
  (1...$data_actors.size).each {|i|
      if $game_actors[i] != nil && $game_actors[i].must_be_in_party &&
           (!$game_actors[i].disabled_for_party || flag) &&
           !$game_actors[i].not_available
        party.push($game_actors[i])
      end}
  party.clone.each {|actor|
      if actor.forced_position != nil
        $game_party.actors[actor.forced_position] = actor
        party.delete(actor)
      end}
  $game_party.actors.each_index {|i|
      $game_party.actors[i] = party.shift if $game_party.actors[i] == nil}
  $game_party.actors += party.compact
end  

def swap_parties
  $game_party.actors.compact!
  temp_actors = $game_party.actors
  temp_actors.each {|actor| actor.not_available = true}
  $game_system.stored_party.compact!
  $game_system.stored_party.each {|actor| actor.not_available = false}
  $game_party.actors = $game_system.stored_party
  $game_system.stored_party = (@store == 1 ? temp_actors : nil)
end

def call_warning?(index, actor2)
  return (ALLOW_EMPTY_PARTY || $game_party.actors[index] == nil ||
      actor2 != nil || $game_party.actors.nitems > 1)
end

def warning(flag = false)
  $game_system.se_play($data_system.buzzer_se)
  @warning_window = Window_Warning.new(flag, @reserve_window.get_number)
  loop do
    Graphics.update
    Input.update
    if Input.trigger?(Input::C)
      $game_system.se_play($data_system.decision_se) if flag
      [@current_window, @reserve_window].each {|win| win.refresh}
      @warning_window.dispose
      @warning_window = nil
      break
    end
  end
end

end

#==============================================================================
# Scene_Battle
#==============================================================================

class Scene_Battle

alias start_phase5_eps_later start_phase5
def start_phase5
  start_phase5_eps_later
  (1...$data_actors.size).each {|i|
      unless $game_party.actors.include?($game_actors[i])
        if $game_actors[i].not_available
          $game_actors[i].exp += @result_window.exp * EXP_NOT_AVAILABLE/100
        elsif $game_actors[i].disabled_for_party
          $game_actors[i].exp += @result_window.exp * EXP_DISABLED_FOR_PARTY/100
        else
          $game_actors[i].exp += @result_window.exp * EXP_RESERVE/100
        end
      end}
end

end

spero di averlo messo bene(l'ho messo su code box....o lo devo mettere su spoiler...hmm....vabbè in caso me lo di te che lo modifico)

September 7, 2007

adesso mi evoca 1 personaggio....però il problema dll'evocazione che non fà niente rimane...succede solo a me o è un bug da correggere????

ho tolto lo script delle barre hp mp e atb...e adesso funziona!!!grazie mille se riuscirò a finire il gioco ti crediterò(perchè è tutto un mistero....in 1 è un pò difficile finire un gioco)

September 6, 2007

scusate...a me non funziona :sisi:

ovvero quando avvio l'evocazione non mi fà attaccare e sopratutto...come si cambiano i personaggi dello script??'

September 3, 2007

scusate la mia ignoranza,fino agli eventi so cosa sono...ma il tinmer cosa è???

September 1, 2007

c'è un modo per fare delle turbo alla FFX??ossia premere una determinata sequenza di tasti per fare una determinata mossa???

P.S:non ho usato il tasto cerca perchè non sapevo cosa cercare....

Sign In

metaldrack

Posts

Joined

Last visited

Content Type

Profiles

Forums

Calendar

Posts posted by metaldrack

caterpillar by Trickster adattato al VX

aggiunte al menu di base di rpg maker vx

caterpillar by Trickster adattato al VX

cambio del party

*Aeon System

*Aeon System

turbo alla FFX

turbo alla FFX

Browse

Activity