[RISOLTO] Impedire che la variabile torni a "nil" ad ogni avvio

Blake · March 23, 2008

Se non vi va di leggere sto papiro, scritto mentre cercavo soluzioni per conto mio, basta guardare l'ultima riga :wink: .

Mi sono innamorato della grafica rtp del VX, così ho inventato una storiella per i vari pg e ci ho giocato un pochino. Volevo una scena con una serie di battaglie ed una traccia musicale continua (come l'attacco a dollet in final fantasy 8, per intenderci), così ho aperto l'rgss editor pensando "quanto vuoi che sia difficile?".

Effettivamente non era tanto complicato, ho cercato in scene_map ed in scene_battle le stringhe che cambiavano musica e le ho circondate con

"if $musica == false" e relativo end, così che la musica non cambiasse quando $musica è true.

(Il doppio uguale me l'ha dovuto suggerire progm, dopo ore che smanettavo :angry: )

Ed infatti funziona.

Finché non riavvio il programma.

Anche iniziando il gioco, se non specifico "$musica = false", il gioco la tratta come se fosse true e non cambia la musica per i combattimenti. Caricando una partita in cui $musica dovrebbe essere false, succede la stessa cosa.

Perché? Non dovrebbe essere false di default?

Parlando con Wiz e leggendo un po' il manuale di rgss, ho trovato che non era true ma "nil" <.<.

Risolvo mettendo if $musica == nil, ma non c'è un modo per impedire il reset ad ogni avvio?

Edited April 8, 2008 by Marigno

Sylaer · March 23, 2008

Si devi salvarle all'interno di un file, come per esempio il file di salvataggio, le scene da modificare sono Scene_Save e Scene_Load.

PSYKO · March 23, 2008

Senti Blake, potresti postare questo minigame

con le relative spiegazioni che mi hai incuriosito?

La cosa è interessante

Grazie mille :wink:

Blake · March 24, 2008

Si devi salvarle all'interno di un file, come per esempio il file di salvataggio, le scene da modificare sono Scene_Save e Scene_Load.

Heh, ci avevo pensato, ma per me là è tutto arabo :angry: .

Senti Blake, potresti postare questo minigame
con le relative spiegazioni che mi hai incuriosito?
La cosa è interessante
Grazie mille

Hmm non è un minigame, ho solo messo un bgm fisso tra battaglia, vittoria e mappa.

Normalmente, anche se battaglia e mappa hanno stesso bgm, la musica riparte da capo ogni volta che inizia una battaglia. Io ho messo una condizione che rende inaccessibili quelle tre/quattro stringhe che resettano la musica. Se ti interessa ancora posto, tanto è davvero una stupidata...

Tio · March 24, 2008

hai provato ad usare ua delle variabili di gioco, invece di creare una variabile globale?

cioè, invece di $musica, usi $game_switches[numero] == true/false .. con quelle non dovrebbe darti problemi perchè vengono caricate sempre automaticamente ogni volta che inizi o carichi una partita.

Blake · March 24, 2008

hai provato ad usare ua delle variabili di gioco, invece di creare una variabile globale?
cioè, invece di $musica, usi $game_switches[numero] == true/false .. con quelle non dovrebbe darti problemi perchè vengono caricate sempre automaticamente ogni volta che inizi o carichi una partita.

Ecco, QUESTO lo adoro! :D

Grazie infinite, provo subito.

PSYKO · March 24, 2008

A me farebbe comodo perchè c'è un pezzo nel mio progetto dove mappa e Arena hanno lo stesso BGM..

se non ti disturba..

Blake · March 24, 2008

A me farebbe comodo perchè c'è un pezzo nel mio progetto dove mappa e Arena hanno lo stesso BGM..
se non ti disturba..

Io ho fatto così, sicuramente esiste un metodo migliore perché sono un niubbo di script, comunque eccolo:

scene_map, righe 203-210:

if $game_switches[41] == false
RPG::BGM.stop
RPG::BGS.stop
end
 Sound.play_battle_start
if $game_switches[41] == false
$game_system.battle_bgm.play
end

scene_battle, 208-211:

if $game_switches[41] == false
	$game_temp.map_bgm.play
	$game_temp.map_bgs.play
	end

scene_battle, 589-597:

if $game_switches[41] == false
RPG::BGM.stop
$game_system.battle_end_me.play
end
unless $BTEST
  if $game_switches[41] == false
  $game_temp.map_bgm.play
  $game_temp.map_bgs.play
  end

nota che io ho messo $game_switches[41] perché uso la switch 41, tu mettici il numero che ti pare :P (ovviamente sempre lo stesso).

Con la switch OFF sarà tutto normale, con la switch ON resterà sempre lo stesso bgm.

Sylaer · March 24, 2008

Blake, perché scomodare le switch che servono per gli eventi, quando puoi utilizzare lo script:

ad esempio il Game_System è la classe dove ci metti tutta roba che deve essere salvata su un salvataggio, quindi crei una nuova variabile lì e utilizzi quella es.

class Game_System
attr_accessor music
alias game_system_music_initialize initialize
def initialize
@music = false # oppure true decidi te
game_system_music_initialize
end
end

Schiaffi questo in una nuova classe sotto Game_System oppure copi le linee 2,3 e 5 all'interno del Game_System originale, poi puoi liberamente utilizzare il comando

$game_system.music

per indicare quella variabile e settarla.

Edited March 24, 2008 by Sylaer

Blake · March 24, 2008

Blake, perché scomodare le switch che servono per gli eventi, quando puoi utilizzare lo script:
ad esempio il Game_System è la classe dove ci metti tutta roba che deve essere salvata su un salvataggio, quindi crei una nuova variabile lì e utilizzi quella es.
class Game_System
attr_accessor music
alias game_system_music_initialize initialize
def initialize
@music = false # oppure true decidi te
game_system_music_initialize
end
end
Schiaffi questo in una nuova classe sotto Game_System oppure copi le linee 2,3 e 5 all'interno del Game_System originale, poi puoi liberamente utilizzare il comando
$game_system.music
per indicare quella variabile e settarla.

Ti ringrazio, ma, adesso che mi funziona, ho paura a rimetterci le mani :wink: .

PSYKO · March 24, 2008

Sono l'unico he non ci capise una mazza??? :wink:

Blake · March 24, 2008

Sono l'unico he non ci capise una mazza???

Sostituisci scene_map con questo:

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs the map screen processing.
#==============================================================================

class Scene_Map < Scene_Base
 #--------------------------------------------------------------------------
 # * Start processing
 #--------------------------------------------------------------------------
 def start
super
$game_map.refresh
@spriteset = Spriteset_Map.new
@message_window = Window_Message.new
 end
 #--------------------------------------------------------------------------
 # * Execute Transition
 #--------------------------------------------------------------------------
 def perform_transition
if Graphics.brightness == 0	   # After battle or loading, etc.
  fadein(30)
else							  # Restoration from menu, etc.
  Graphics.transition(15)
end
 end
 #--------------------------------------------------------------------------
 # * Termination Processing
 #--------------------------------------------------------------------------
 def terminate
super
if $scene.is_a?(Scene_Battle)	 # If switching to battle screen
  @spriteset.dispose_characters   # Hide characters for background creation
end
snapshot_for_background
@spriteset.dispose
@message_window.dispose
if $scene.is_a?(Scene_Battle)	 # If switching to battle screen
  perform_battle_transition	   # Execute pre-battle transition
end
 end
 #--------------------------------------------------------------------------
 # * Basic Update Processing
 #--------------------------------------------------------------------------
 def update_basic
Graphics.update				   # Update game screen
Input.update					  # Update input information
$game_map.update				  # Update map
@spriteset.update				 # Update sprite set
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
super
$game_map.interpreter.update	  # Update interpreter
$game_map.update				  # Update map
$game_player.update			   # Update player
$game_system.update			   # Update timer
@spriteset.update				 # Update sprite set
@message_window.update			# Update message window
unless $game_message.visible	  # Unless displaying a message
  update_transfer_player
  update_encounter
  update_call_menu
  update_call_debug
  update_scene_change
end
 end
 #--------------------------------------------------------------------------
 # * Fade In Screen
 #	 duration : time
 #	If you use Graphics.fadeout directly on the map screen, a number of
 #	problems can occur, such as weather effects and parallax  scrolling
 #	being stopped. So instead, perform a dynamic fade-in.
 #--------------------------------------------------------------------------
 def fadein(duration)
Graphics.transition(0)
for i in 0..duration-1
  Graphics.brightness = 255 * i / duration
  update_basic
end
Graphics.brightness = 255
 end
 #--------------------------------------------------------------------------
 # * Fade Out Screen
 #	 duration : time
 #	As with the fadein above, Graphics.fadein is not used directly.
 #--------------------------------------------------------------------------
 def fadeout(duration)
Graphics.transition(0)
for i in 0..duration-1
  Graphics.brightness = 255 - 255 * i / duration
  update_basic
end
Graphics.brightness = 0
 end
 #--------------------------------------------------------------------------
 # * Player Transfer  Processing
 #--------------------------------------------------------------------------
 def update_transfer_player
return unless $game_player.transfer?
fade = (Graphics.brightness > 0)
fadeout(30) if fade
@spriteset.dispose			  # Dispose of sprite set
$game_player.perform_transfer   # Execute player transfer
$game_map.autoplay			  # Automatically switch BGM and BGS
$game_map.update
Graphics.wait(15)
@spriteset = Spriteset_Map.new  # Recreate sprite set
fadein(30) if fade
Input.update
 end
 #--------------------------------------------------------------------------
 # * Encounter Processing
 #--------------------------------------------------------------------------
 def update_encounter
return if $game_player.encounter_count > 0		# Check steps
return if $game_map.interpreter.running?		  # Event being executed?
return if $game_system.encounter_disabled		 # Encounters forbidden?
troop_id = $game_player.make_encounter_troop_id   # Determine troop
return if $data_troops[troop_id] == nil		   # Troop is invalid?
$game_troop.setup(troop_id)
$game_troop.can_escape = true
$game_temp.battle_proc = nil
$game_temp.next_scene = "battle"
preemptive_or_surprise
 end
 #--------------------------------------------------------------------------
 # * Determine Preemptive Strike and Surprise Attack Chance
 #--------------------------------------------------------------------------
 def preemptive_or_surprise
actors_agi = $game_party.average_agi
enemies_agi = $game_troop.average_agi
if actors_agi >= enemies_agi
  percent_preemptive = 5
  percent_surprise = 3
else
  percent_preemptive = 3
  percent_surprise = 5
end
if rand(100) < percent_preemptive
  $game_troop.preemptive = true
elsif rand(100) < percent_surprise
  $game_troop.surprise = true
end
 end
 #--------------------------------------------------------------------------
 # * Determine if Menu is Called due to Cancel Button
 #--------------------------------------------------------------------------
 def update_call_menu
if Input.trigger?(Input::B)
  return if $game_map.interpreter.running?		# Event being executed?
  return if $game_system.menu_disabled			# Menu forbidden?
  $game_temp.menu_beep = true					 # Set SE play flag
  $game_temp.next_scene = "menu"
end
 end
 #--------------------------------------------------------------------------
 # * Determine Bug Call Due to F9 key
 #--------------------------------------------------------------------------
 def update_call_debug
if $TEST and Input.press?(Input::F9)	# F9 key during test play
  $game_temp.next_scene = "debug"
end
 end
 #--------------------------------------------------------------------------
 # * Execute Screen Switch
 #--------------------------------------------------------------------------
 def update_scene_change
return if $game_player.moving?	# Is player moving?
case $game_temp.next_scene
when "battle"
  call_battle
when "shop"
  call_shop
when "name"
  call_name
when "menu"
  call_menu
when "save"
  call_save
when "debug"
  call_debug
when "gameover"
  call_gameover
when "title"
  call_title
else
  $game_temp.next_scene = nil
end
 end
 #--------------------------------------------------------------------------
 # * Switch to Battle Screen
 #--------------------------------------------------------------------------
 def call_battle
@spriteset.update
Graphics.update
$game_player.make_encounter_count
$game_player.straighten
$game_temp.map_bgm = RPG::BGM.last
$game_temp.map_bgs = RPG::BGS.last
if $game_switches[41] == false
RPG::BGM.stop
RPG::BGS.stop
end
 Sound.play_battle_start
if $game_switches[41] == false
$game_system.battle_bgm.play
end
$game_temp.next_scene = nil
$scene = Scene_Battle.new
 end
 #--------------------------------------------------------------------------
 # * Switch to Shop Screen
 #--------------------------------------------------------------------------
 def call_shop
$game_temp.next_scene = nil
$scene = Scene_Shop.new
 end
 #--------------------------------------------------------------------------
 # * Switch to Name Input Screen
 #--------------------------------------------------------------------------
 def call_name
$game_temp.next_scene = nil
$scene = Scene_Name.new
 end
 #--------------------------------------------------------------------------
 # * Switch to Menu Screen
 #--------------------------------------------------------------------------
 def call_menu
if $game_temp.menu_beep
  Sound.play_decision
  $game_temp.menu_beep = false
end
$game_temp.next_scene = nil
$scene = Scene_Menu.new
 end
 #--------------------------------------------------------------------------
 # * Switch to Save Screen
 #--------------------------------------------------------------------------
 def call_save
$game_temp.next_scene = nil
$scene = Scene_File.new(true, false, true)
 end
 #--------------------------------------------------------------------------
 # * Switch to Debug Screen
 #--------------------------------------------------------------------------
 def call_debug
Sound.play_decision
$game_temp.next_scene = nil
$scene = Scene_Debug.new
 end
 #--------------------------------------------------------------------------
 # * Switch to Game Over Screen
 #--------------------------------------------------------------------------
 def call_gameover
$game_temp.next_scene = nil
$scene = Scene_Gameover.new
 end
 #--------------------------------------------------------------------------
 # * Switch to Title Screen
 #--------------------------------------------------------------------------
 def call_title
$game_temp.next_scene = nil
$scene = Scene_Title.new
fadeout(60)
 end
 #--------------------------------------------------------------------------
 # * Execute Pre-battle Transition
 #--------------------------------------------------------------------------
 def perform_battle_transition
Graphics.transition(80, "Graphics/System/BattleStart", 80)
Graphics.freeze
 end
end

e scene_battle con questo:

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

class Scene_Battle < Scene_Base
 #--------------------------------------------------------------------------
 # * Start processing
 #--------------------------------------------------------------------------
 def start
super
$game_temp.in_battle = true
@spriteset = Spriteset_Battle.new
@message_window = Window_BattleMessage.new
@action_battlers = []
create_info_viewport
 end
 #--------------------------------------------------------------------------
 # * Post-Start Processing
 #--------------------------------------------------------------------------
 def post_start
super
process_battle_start
 end
 #--------------------------------------------------------------------------
 # * Termination Processing
 #--------------------------------------------------------------------------
 def terminate
super
dispose_info_viewport
@message_window.dispose
@spriteset.dispose
unless $scene.is_a?(Scene_Gameover)
  $scene = nil if $BTEST
end
 end
 #--------------------------------------------------------------------------
 # * Basic Update Processing
 #	 main : Call from main update method
 #--------------------------------------------------------------------------
 def update_basic(main = false)
Graphics.update unless main	 # Update game screen
Input.update unless main		# Update input information
$game_system.update			 # Update timer
$game_troop.update			  # Update enemy group
@spriteset.update			   # Update sprite set
@message_window.update		  # Update message window
 end
 #--------------------------------------------------------------------------
 # * Wait a set amount of time
 #	 duration : Wait time (number of frames)
 #	 no_fast  : Fast forward disabled
 #	A method for inserting a wait during scene class update processing.
 #	As a rule, update is called once for each frame, but during battle it
 #	can be difficult to grasp the processing flow, so this method is used#
 #	as an exception.
 #--------------------------------------------------------------------------
 def wait(duration, no_fast = false)
for i in 0...duration
  update_basic
  break if not no_fast and i >= duration / 2 and show_fast?
end
 end
 #--------------------------------------------------------------------------
 # * Wait Until Message Display has Finished
 #--------------------------------------------------------------------------
 def wait_for_message
@message_window.update
while $game_message.visible
  update_basic
end
 end
 #--------------------------------------------------------------------------
 # * Wait Until Animation Display has Finished
 #--------------------------------------------------------------------------
 def wait_for_animation
while @spriteset.animation?
  update_basic
end
 end
 #--------------------------------------------------------------------------
 # * Determine Fast Forward
 #--------------------------------------------------------------------------
 def show_fast?
return (Input.press?(Input::A) or Input.press?(Input::C))
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
super
update_basic(true)
update_info_viewport				  # Update information viewport
if $game_message.visible
  @info_viewport.visible = false
  @message_window.visible = true
end
unless $game_message.visible		  # Unless displaying a message
  return if judge_win_loss			# Determine win/loss results
  update_scene_change
  if @target_enemy_window != nil
	update_target_enemy_selection	 # Select target enemy
  elsif @target_actor_window != nil
	update_target_actor_selection	 # Select target actor
  elsif @skill_window != nil
	update_skill_selection			# Select skill
  elsif @item_window != nil
	update_item_selection			 # Select item
  elsif @party_command_window.active
	update_party_command_selection	# Select party command
  elsif @actor_command_window.active
	update_actor_command_selection	# Select actor command
  else
	process_battle_event			  # Battle event processing
	process_action					# Battle action
	process_battle_event			  # Battle event processing
  end
end
 end
 #--------------------------------------------------------------------------
 # * Create Information Display Viewport
 #--------------------------------------------------------------------------
 def create_info_viewport
@info_viewport = Viewport.new(0, 288, 544, 128)
@info_viewport.z = 100
@status_window = Window_BattleStatus.new
@party_command_window = Window_PartyCommand.new
@actor_command_window = Window_ActorCommand.new
@status_window.viewport = @info_viewport
@party_command_window.viewport = @info_viewport
@actor_command_window.viewport = @info_viewport
@status_window.x = 128
@actor_command_window.x = 544
@info_viewport.visible = false
 end
 #--------------------------------------------------------------------------
 # * Dispose of Information Display Viewport
 #--------------------------------------------------------------------------
 def dispose_info_viewport
@status_window.dispose
@party_command_window.dispose
@actor_command_window.dispose
@info_viewport.dispose
 end
 #--------------------------------------------------------------------------
 # * Update Information Display Viewport
 #--------------------------------------------------------------------------
 def update_info_viewport
@party_command_window.update
@actor_command_window.update
@status_window.update
if @party_command_window.active and @info_viewport.ox > 0
  @info_viewport.ox -= 16
elsif @actor_command_window.active and @info_viewport.ox < 128
  @info_viewport.ox += 16
end
 end
 #--------------------------------------------------------------------------
 # * Battle Event Processing
 #--------------------------------------------------------------------------
 def process_battle_event
loop do
  return if judge_win_loss
  return if $game_temp.next_scene != nil
  $game_troop.interpreter.update
  $game_troop.setup_battle_event
  wait_for_message
  process_action if $game_troop.forcing_battler != nil
  return unless $game_troop.interpreter.running?
  update_basic
end
 end
 #--------------------------------------------------------------------------
 # * Determine Win/Loss Results
 #--------------------------------------------------------------------------
 def judge_win_loss
if $game_temp.in_battle
  if $game_party.all_dead?
	process_defeat
	return true
  elsif $game_troop.all_dead?
	process_victory
	return true
  else
	return false
  end
else
  return true
end
 end
 #--------------------------------------------------------------------------
 # * End Battle
 #	 result : Results (0: win, 1: escape, 2:lose)
 #--------------------------------------------------------------------------
 def battle_end(result)
if result == 2 and not $game_troop.can_lose
  call_gameover
else
  $game_party.clear_actions
  $game_party.remove_states_battle
  $game_troop.clear
  if $game_temp.battle_proc != nil
	$game_temp.battle_proc.call(result)
	$game_temp.battle_proc = nil
  end
  unless $BTEST
	if $game_switches[41] == false
	$game_temp.map_bgm.play
	$game_temp.map_bgs.play
	end
  end
  $scene = Scene_Map.new
  @message_window.clear
  Graphics.fadeout(30)
end
$game_temp.in_battle = false
 end
 #--------------------------------------------------------------------------
 # * Go to Command Input for Next Actor
 #--------------------------------------------------------------------------
 def next_actor
loop do
  if @actor_index == $game_party.members.size-1
	start_main
	return
  end
  @status_window.index = @actor_index += 1
  @active_battler = $game_party.members[@actor_index]
  if @active_battler.auto_battle
	@active_battler.make_action
	next
  end
  break if @active_battler.inputable?
end
start_actor_command_selection
 end
 #--------------------------------------------------------------------------
 # * Go to Command Input of Previous Actor
 #--------------------------------------------------------------------------
 def prior_actor
loop do
  if @actor_index == 0
	start_party_command_selection
	return
  end
  @status_window.index = @actor_index -= 1
  @active_battler = $game_party.members[@actor_index]
  next if @active_battler.auto_battle
  break if @active_battler.inputable?
end
start_actor_command_selection
 end
 #--------------------------------------------------------------------------
 # * Start party command selection
 #--------------------------------------------------------------------------
 def start_party_command_selection
if $game_temp.in_battle
  @status_window.refresh
  @status_window.index = @actor_index = -1
  @active_battler = nil
  @info_viewport.visible = true
  @message_window.visible = false
  @party_command_window.active = true
  @party_command_window.index = 0
  @actor_command_window.active = false
  $game_party.clear_actions
  if $game_troop.surprise or not $game_party.inputable?
	start_main
  end
end
 end
 #--------------------------------------------------------------------------
 # * Update Party Command Selection
 #--------------------------------------------------------------------------
 def update_party_command_selection
if Input.trigger?(Input::C)
  case @party_command_window.index
  when 0  # Fight
	Sound.play_decision
	@status_window.index = @actor_index = -1
	next_actor
  when 1  # Escape
	if $game_troop.can_escape == false
	  Sound.play_buzzer
	  return
	end
	Sound.play_decision
	process_escape
  end
end
 end
 #--------------------------------------------------------------------------
 # * Start Actor Command Selection
 #--------------------------------------------------------------------------
 def start_actor_command_selection
@party_command_window.active = false
@actor_command_window.setup(@active_battler)
@actor_command_window.active = true
@actor_command_window.index = 0
 end
 #--------------------------------------------------------------------------
 # * Update Actor Command Selection
 #--------------------------------------------------------------------------
 def update_actor_command_selection
if Input.trigger?(Input::B)
  Sound.play_cancel
  prior_actor
elsif Input.trigger?(Input::C)
  case @actor_command_window.index
  when 0  # Attack
	Sound.play_decision
	@active_battler.action.set_attack
	start_target_enemy_selection
  when 1  # Skill
	Sound.play_decision
	start_skill_selection
  when 2  # Guard
	Sound.play_decision
	@active_battler.action.set_guard
	next_actor
  when 3  # Item
	Sound.play_decision
	start_item_selection
  end
end
 end
 #--------------------------------------------------------------------------
 # * Start Target Enemy Selection
 #--------------------------------------------------------------------------
 def start_target_enemy_selection
@target_enemy_window = Window_TargetEnemy.new
@target_enemy_window.y = @info_viewport.rect.y
@info_viewport.rect.x += @target_enemy_window.width
@info_viewport.ox += @target_enemy_window.width
@actor_command_window.active = false
 end
 #--------------------------------------------------------------------------
 # * End Target Enemy Selection
 #--------------------------------------------------------------------------
 def end_target_enemy_selection
@info_viewport.rect.x -= @target_enemy_window.width
@info_viewport.ox -= @target_enemy_window.width
@target_enemy_window.dispose
@target_enemy_window = nil
if @actor_command_window.index == 0
  @actor_command_window.active = true
end
 end
 #--------------------------------------------------------------------------
 # * Update Target Enemy Selection
 #--------------------------------------------------------------------------
 def update_target_enemy_selection
@target_enemy_window.update
if Input.trigger?(Input::B)
  Sound.play_cancel
  end_target_enemy_selection
elsif Input.trigger?(Input::C)
  Sound.play_decision
  @active_battler.action.target_index = @target_enemy_window.enemy.index
  end_target_enemy_selection
  end_skill_selection
  end_item_selection
  next_actor
end
 end
 #--------------------------------------------------------------------------
 # * Start Target Actor Selection
 #--------------------------------------------------------------------------
 def start_target_actor_selection
@target_actor_window = Window_BattleStatus.new
@target_actor_window.index = 0
@target_actor_window.active = true
@target_actor_window.y = @info_viewport.rect.y
@info_viewport.rect.x += @target_actor_window.width
@info_viewport.ox += @target_actor_window.width
@actor_command_window.active = false
 end
 #--------------------------------------------------------------------------
 # * End Target Actor Selection
 #--------------------------------------------------------------------------
 def end_target_actor_selection
@info_viewport.rect.x -= @target_actor_window.width
@info_viewport.ox -= @target_actor_window.width
@target_actor_window.dispose
@target_actor_window = nil
 end
 #--------------------------------------------------------------------------
 # * Update Target Actor Selection
 #--------------------------------------------------------------------------
 def update_target_actor_selection
@target_actor_window.update
if Input.trigger?(Input::B)
  Sound.play_cancel
  end_target_actor_selection
elsif Input.trigger?(Input::C)
  Sound.play_decision
  @active_battler.action.target_index = @target_actor_window.index
  end_target_actor_selection
  end_skill_selection
  end_item_selection
  next_actor
end
 end
 #--------------------------------------------------------------------------
 # * Start Skill Selection
 #--------------------------------------------------------------------------
 def start_skill_selection
@help_window = Window_Help.new
@skill_window = Window_Skill.new(0, 56, 544, 232, @active_battler)
@skill_window.help_window = @help_window
@actor_command_window.active = false
 end
 #--------------------------------------------------------------------------
 # * End Skill Selection
 #--------------------------------------------------------------------------
 def end_skill_selection
if @skill_window != nil
  @skill_window.dispose
  @skill_window = nil
  @help_window.dispose
  @help_window = nil
end
@actor_command_window.active = true
 end
 #--------------------------------------------------------------------------
 # * Update Skill Selection
 #--------------------------------------------------------------------------
 def update_skill_selection
@skill_window.active = true
@skill_window.update
@help_window.update
if Input.trigger?(Input::B)
  Sound.play_cancel
  end_skill_selection
elsif Input.trigger?(Input::C)
  @skill = @skill_window.skill
  if @skill != nil
	@active_battler.last_skill_id = @skill.id
  end
  if @active_battler.skill_can_use?(@skill)
	Sound.play_decision
	determine_skill
  else
	Sound.play_buzzer
  end
end
 end
 #--------------------------------------------------------------------------
 # * Confirm Skill
 #--------------------------------------------------------------------------
 def determine_skill
@active_battler.action.set_skill(@skill.id)
@skill_window.active = false
if @skill.need_selection?
  if @skill.for_opponent?
	start_target_enemy_selection
  else
	start_target_actor_selection
  end
else
  end_skill_selection
  next_actor
end
 end
 #--------------------------------------------------------------------------
 # * Start Item Selection
 #--------------------------------------------------------------------------
 def start_item_selection
@help_window = Window_Help.new
@item_window = Window_Item.new(0, 56, 544, 232)
@item_window.help_window = @help_window
@actor_command_window.active = false
 end
 #--------------------------------------------------------------------------
 # * End Item Selection
 #--------------------------------------------------------------------------
 def end_item_selection
if @item_window != nil
  @item_window.dispose
  @item_window = nil
  @help_window.dispose
  @help_window = nil
end
@actor_command_window.active = true
 end
 #--------------------------------------------------------------------------
 # * Update Item Selection
 #--------------------------------------------------------------------------
 def update_item_selection
@item_window.active = true
@item_window.update
@help_window.update
if Input.trigger?(Input::B)
  Sound.play_cancel
  end_item_selection
elsif Input.trigger?(Input::C)
  @item = @item_window.item
  if @item != nil
	$game_party.last_item_id = @item.id
  end
  if $game_party.item_can_use?(@item)
	Sound.play_decision
	determine_item
  else
	Sound.play_buzzer
  end
end
 end
 #--------------------------------------------------------------------------
 # * Confirm Item
 #--------------------------------------------------------------------------
 def determine_item
@active_battler.action.set_item(@item.id)
@item_window.active = false
if @item.need_selection?
  if @item.for_opponent?
	start_target_enemy_selection
  else
	start_target_actor_selection
  end
else
  end_item_selection
  next_actor
end
 end
 #--------------------------------------------------------------------------
 # * Battle Start Processing
 #--------------------------------------------------------------------------
 def process_battle_start
@message_window.clear
wait(10)
for name in $game_troop.enemy_names
  text = sprintf(Vocab::Emerge, name)
  $game_message.texts.push(text)
end
if $game_troop.preemptive
  text = sprintf(Vocab::Preemptive, $game_party.name)
  $game_message.texts.push(text)
elsif $game_troop.surprise
  text = sprintf(Vocab::Surprise, $game_party.name)
  $game_message.texts.push(text)
end
wait_for_message
@message_window.clear
make_escape_ratio
process_battle_event
start_party_command_selection
 end
 #--------------------------------------------------------------------------
 # * Create Escape Ratio
 #--------------------------------------------------------------------------
 def make_escape_ratio
actors_agi = $game_party.average_agi
enemies_agi = $game_troop.average_agi
@escape_ratio = 150 - 100 * enemies_agi / actors_agi
 end
 #--------------------------------------------------------------------------
 # * Escape Processing
 #--------------------------------------------------------------------------
 def process_escape
@info_viewport.visible = false
@message_window.visible = true
text = sprintf(Vocab::EscapeStart, $game_party.name)
$game_message.texts.push(text)
if $game_troop.preemptive
  success = true
else
  success = (rand(100) < @escape_ratio)
end
Sound.play_escape
if success
  wait_for_message
  battle_end(1)
else
  @escape_ratio += 10
  $game_message.texts.push('\.' + Vocab::EscapeFailure)
  wait_for_message
  $game_party.clear_actions
  start_main
end
 end
 #--------------------------------------------------------------------------
 # * Victory Processing
 #--------------------------------------------------------------------------
 def process_victory
@info_viewport.visible = false
@message_window.visible = true
if $game_switches[41] == false
RPG::BGM.stop
$game_system.battle_end_me.play
end
unless $BTEST
  if $game_switches[41] == false
  $game_temp.map_bgm.play
  $game_temp.map_bgs.play
  end
end
display_exp_and_gold
display_drop_items
display_level_up
battle_end(0)
 end
 #--------------------------------------------------------------------------
 # * Display Gained Experience and Gold
 #--------------------------------------------------------------------------
 def display_exp_and_gold
exp = $game_troop.exp_total
gold = $game_troop.gold_total
$game_party.gain_gold(gold)
text = sprintf(Vocab::Victory, $game_party.name)
$game_message.texts.push('\|' + text)
if exp > 0
  text = sprintf(Vocab::ObtainExp, exp)
  $game_message.texts.push('\.' + text)
end
if gold > 0
  text = sprintf(Vocab::ObtainGold, gold, Vocab::gold)
  $game_message.texts.push('\.' + text)
end
wait_for_message
 end
 #--------------------------------------------------------------------------
 # * Display Gained Drop Items
 #--------------------------------------------------------------------------
 def display_drop_items
drop_items = $game_troop.make_drop_items
for item in drop_items
  $game_party.gain_item(item, 1)
  text = sprintf(Vocab::ObtainItem, item.name)
  $game_message.texts.push(text)
end
wait_for_message
 end
 #--------------------------------------------------------------------------
 # * Display Level Up
 #--------------------------------------------------------------------------
 def display_level_up
exp = $game_troop.exp_total
for actor in $game_party.existing_members
  last_level = actor.level
  last_skills = actor.skills
  actor.gain_exp(exp, true)
end
wait_for_message
 end
 #--------------------------------------------------------------------------
 # * Defeat Processing
 #--------------------------------------------------------------------------
 def process_defeat
@info_viewport.visible = false
@message_window.visible = true
text = sprintf(Vocab::Defeat, $game_party.name)
$game_message.texts.push(text)
wait_for_message
battle_end(2)
 end
 #--------------------------------------------------------------------------
 # * Execute Screen Switch
 #--------------------------------------------------------------------------
 def update_scene_change
case $game_temp.next_scene
when "map"
  call_map
when "gameover"
  call_gameover
when "title"
  call_title
else
  $game_temp.next_scene = nil
end
 end
 #--------------------------------------------------------------------------
 # * Switch to Map Screen
 #--------------------------------------------------------------------------
 def call_map
$game_temp.next_scene = nil
battle_end(1)
 end
 #--------------------------------------------------------------------------
 # * Switch to Game Over Screen
 #--------------------------------------------------------------------------
 def call_gameover
$game_temp.next_scene = nil
$scene = Scene_Gameover.new
@message_window.clear
 end
 #--------------------------------------------------------------------------
 # * Switch to Title Screen
 #--------------------------------------------------------------------------
 def call_title
$game_temp.next_scene = nil
$scene = Scene_Title.new
@message_window.clear
Graphics.fadeout(60)
 end
 #--------------------------------------------------------------------------
 # * Start Execution of Battle Processing
 #--------------------------------------------------------------------------
 def start_main
$game_troop.increase_turn
@info_viewport.visible = false
@info_viewport.ox = 0
@message_window.visible = true
@party_command_window.active = false
@actor_command_window.active = false
@status_window.index = @actor_index = -1
@active_battler = nil
@message_window.clear
$game_troop.make_actions
make_action_orders
wait(20)
 end
 #--------------------------------------------------------------------------
 # * Create Action Orders
 #--------------------------------------------------------------------------
 def make_action_orders
@action_battlers = []
unless $game_troop.surprise
  @action_battlers += $game_party.members
end
unless $game_troop.preemptive
  @action_battlers += $game_troop.members
end
for battler in @action_battlers
  battler.action.make_speed
end
@action_battlers.sort! do |a,b|
  b.action.speed - a.action.speed
end
 end
 #--------------------------------------------------------------------------
 # * Battle Action Processing
 #--------------------------------------------------------------------------
 def process_action
return if judge_win_loss
return if $game_temp.next_scene != nil
set_next_active_battler
if @active_battler == nil
  turn_end
  return
end
@message_window.clear
wait(5)
@active_battler.white_flash = true
unless @active_battler.action.forcing
  @active_battler.action.prepare
end
if @active_battler.action.valid?
  execute_action
end
unless @active_battler.action.forcing
  @message_window.clear
  remove_states_auto
  display_current_state
end
@active_battler.white_flash = false
@message_window.clear
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Actions
 #--------------------------------------------------------------------------
 def execute_action
case @active_battler.action.kind
when 0  # Basic
  case @active_battler.action.basic
  when 0  # Attack
	execute_action_attack
  when 1  # Guard
	execute_action_guard
  when 2  # Escape
	execute_action_escape
  when 3  # Wait
	execute_action_wait
  end
when 1  # Skill
  execute_action_skill
when 2  # Item
  execute_action_item
end
 end
 #--------------------------------------------------------------------------
 # * End Turn
 #--------------------------------------------------------------------------
 def turn_end
$game_troop.turn_ending = true
$game_party.slip_damage_effect
$game_troop.slip_damage_effect
$game_party.do_auto_recovery
$game_troop.preemptive = false
$game_troop.surprise = false
process_battle_event
$game_troop.turn_ending = false
start_party_command_selection
 end
 #--------------------------------------------------------------------------
 # * Set Next Battler to Act
 #	When the [Force Battle Action] event command is being performed, set
 #	that battler and remove him from the list. Otherwise, get from top of
 #	list. If an actor that is not currently in the party is obtained (may
 #	occur if the index is nil, just after leaving via a battle event, etc.)
 #	it is skipped.
 #--------------------------------------------------------------------------
 def set_next_active_battler
loop do
  if $game_troop.forcing_battler != nil
	@active_battler = $game_troop.forcing_battler
	@action_battlers.delete(@active_battler)
	$game_troop.forcing_battler = nil
  else
	@active_battler = @action_battlers.shift
  end
  return if @active_battler == nil
  return if @active_battler.index != nil
end
 end
 #--------------------------------------------------------------------------
 # * Natural Removal of States
 #--------------------------------------------------------------------------
 def remove_states_auto
last_st = @active_battler.states
@active_battler.remove_states_auto
if @active_battler.states != last_st
  wait(5)
  display_state_changes(@active_battler)
  wait(30)
  @message_window.clear
end
 end
 #--------------------------------------------------------------------------
 # * Show Current State
 #--------------------------------------------------------------------------
 def display_current_state
state_text = @active_battler.most_important_state_text
unless state_text.empty?
  wait(5)
  text = @active_battler.name + state_text
  @message_window.add_instant_text(text)
  wait(45)
  @message_window.clear
end
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Action: Attack
 #--------------------------------------------------------------------------
 def execute_action_attack
text = sprintf(Vocab::DoAttack, @active_battler.name)
@message_window.add_instant_text(text)
targets = @active_battler.action.make_targets
display_attack_animation(targets)
wait(20)
for target in targets
  target.attack_effect(@active_battler)
  display_action_effects(target)
end
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Action: Guard
 #--------------------------------------------------------------------------
 def execute_action_guard
text = sprintf(Vocab::DoGuard, @active_battler.name)
@message_window.add_instant_text(text)
wait(45)
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Action: Escape
 #--------------------------------------------------------------------------
 def execute_action_escape
text = sprintf(Vocab::DoEscape, @active_battler.name)
@message_window.add_instant_text(text)
@active_battler.escape
Sound.play_escape
wait(45)
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Action: Wait
 #--------------------------------------------------------------------------
 def execute_action_wait
text = sprintf(Vocab::DoWait, @active_battler.name)
@message_window.add_instant_text(text)
wait(45)
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Action: Skill
 #--------------------------------------------------------------------------
 def execute_action_skill
skill = @active_battler.action.skill
text = @active_battler.name + skill.message1
@message_window.add_instant_text(text)
unless skill.message2.empty?
  wait(10)
  @message_window.add_instant_text(skill.message2)
end
targets = @active_battler.action.make_targets
display_animation(targets, skill.animation_id)
@active_battler.mp -= @active_battler.calc_mp_cost(skill)
$game_temp.common_event_id = skill.common_event_id
for target in targets
  target.skill_effect(@active_battler, skill)
  display_action_effects(target, skill)
end
 end
 #--------------------------------------------------------------------------
 # * Execute Battle Action: Item
 #--------------------------------------------------------------------------
 def execute_action_item
item = @active_battler.action.item
text = sprintf(Vocab::UseItem, @active_battler.name, item.name)
@message_window.add_instant_text(text)
targets = @active_battler.action.make_targets
display_animation(targets, item.animation_id)
$game_party.consume_item(item)
$game_temp.common_event_id = item.common_event_id
for target in targets
  target.item_effect(@active_battler, item)
  display_action_effects(target, item)
end
 end
 #--------------------------------------------------------------------------
 # * Show Animation
 #	 targets	  : Target array
 #	 animation_id : Animation ID (-1: same as normal attack)
 #--------------------------------------------------------------------------
 def display_animation(targets, animation_id)
if animation_id < 0
  display_attack_animation(targets)
else
  display_normal_animation(targets, animation_id)
end
wait(20)
wait_for_animation
 end
 #--------------------------------------------------------------------------
 # * Show Attack Animation
 #	 targets : Target array
 #	If enemy, play the [Enemy normal attack] sound effect and wait 
 #	a moment. If actor, take dual wielding into account (display left hand
 #	weapon reversed)
 #--------------------------------------------------------------------------
 def display_attack_animation(targets)
if @active_battler.is_a?(Game_Enemy)
  Sound.play_enemy_attack
  wait(15, true)
else
  aid1 = @active_battler.atk_animation_id
  aid2 = @active_battler.atk_animation_id2
  display_normal_animation(targets, aid1, false)
  display_normal_animation(targets, aid2, true)
end
wait_for_animation
 end
 #--------------------------------------------------------------------------
 # * Show Normal Animation
 #	 targets	  : Target array
 #	 animation_id : Animation ID
 #	 mirror	   : Flip horizontal
 #--------------------------------------------------------------------------
 def display_normal_animation(targets, animation_id, mirror = false)
animation = $data_animations[animation_id]
if animation != nil
  to_screen = (animation.position == 3)	   # Is the positon "screen"?
  for target in targets.uniq
	target.animation_id = animation_id
	target.animation_mirror = mirror
	wait(20, true) unless to_screen		   # If for one, wait
  end
  wait(20, true) if to_screen				 # If for all, wait
end
 end
 #--------------------------------------------------------------------------
 # * Show Action Results
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_action_effects(target, obj = nil)
unless target.skipped
  line_number = @message_window.line_number
  wait(5)
  display_critical(target, obj)
  display_damage(target, obj)
  display_state_changes(target, obj)
  if line_number == @message_window.line_number
	display_failure(target, obj) unless target.states_active?
  end
  if line_number != @message_window.line_number
	wait(30)
  end
  @message_window.back_to(line_number)
end
 end
 #--------------------------------------------------------------------------
 # * Show Critical Hit
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_critical(target, obj = nil)
if target.critical
  if target.actor?
	text = Vocab::CriticalToActor
  else
	text = Vocab::CriticalToEnemy
  end
  @message_window.add_instant_text(text)
  wait(20)
end
 end
 #--------------------------------------------------------------------------
 # * Show Damage
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_damage(target, obj = nil)
if target.missed
  display_miss(target, obj)
elsif target.evaded
  display_evasion(target, obj)
else
  display_hp_damage(target, obj)
  display_mp_damage(target, obj)
end
 end
 #--------------------------------------------------------------------------
 # * Show Miss
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_miss(target, obj = nil)
if obj == nil or obj.physical_attack
  if target.actor?
	text = sprintf(Vocab::ActorNoHit, target.name)
  else
	text = sprintf(Vocab::EnemyNoHit, target.name)
  end
  Sound.play_miss
else
  text = sprintf(Vocab::ActionFailure, target.name)
end
@message_window.add_instant_text(text)
wait(30)
 end
 #--------------------------------------------------------------------------
 # * Show Escape
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_evasion(target, obj = nil)
if target.actor?
  text = sprintf(Vocab::ActorEvasion, target.name)
else
  text = sprintf(Vocab::EnemyEvasion, target.name)
end
Sound.play_evasion
@message_window.add_instant_text(text)
wait(30)
 end
 #--------------------------------------------------------------------------
 # * Show HP Damage
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_hp_damage(target, obj = nil)
if target.hp_damage == 0				# No damage
  return if obj != nil and obj.damage_to_mp
  return if obj != nil and obj.base_damage == 0
  fmt = target.actor? ? Vocab::ActorNoDamage : Vocab::EnemyNoDamage
  text = sprintf(fmt, target.name)
elsif target.absorbed				   # Absorb
  fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
  text = sprintf(fmt, target.name, Vocab::hp, target.hp_damage)
elsif target.hp_damage > 0			  # Damage
  if target.actor?
	text = sprintf(Vocab::ActorDamage, target.name, target.hp_damage)
	Sound.play_actor_damage
	$game_troop.screen.start_shake(5, 5, 10)
  else
	text = sprintf(Vocab::EnemyDamage, target.name, target.hp_damage)
	Sound.play_enemy_damage
	target.blink = true
  end
else									# Recovery
  fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
  text = sprintf(fmt, target.name, Vocab::hp, -target.hp_damage)
  Sound.play_recovery
end
@message_window.add_instant_text(text)
wait(30)
 end
 #--------------------------------------------------------------------------
 # * Show MP Damage
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_mp_damage(target, obj = nil)
return if target.dead?
return if target.mp_damage == 0
if target.absorbed					  # Absorb
  fmt = target.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
  text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)
elsif target.mp_damage > 0			  # Damage
  fmt = target.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
  text = sprintf(fmt, target.name, Vocab::mp, target.mp_damage)
else									# Recovery
  fmt = target.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
  text = sprintf(fmt, target.name, Vocab::mp, -target.mp_damage)
  Sound.play_recovery
end
@message_window.add_instant_text(text)
wait(30)
 end
 #--------------------------------------------------------------------------
 # * Show State Change
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_state_changes(target, obj = nil)
return if target.missed or target.evaded
return unless target.states_active?
if @message_window.line_number < 4
  @message_window.add_instant_text("")
end
display_added_states(target, obj)
display_removed_states(target, obj)
display_remained_states(target, obj)
if @message_window.last_instant_text.empty?
  @message_window.back_one
else
  wait(10)
end
 end
 #--------------------------------------------------------------------------
 # * Show Added State
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_added_states(target, obj = nil)
for state in target.added_states
  if target.actor?
	next if state.message1.empty?
	text = target.name + state.message1
  else
	next if state.message2.empty?
	text = target.name + state.message2
  end
  if state.id == 1					  # Incapacitated
	target.perform_collapse
  end
  @message_window.replace_instant_text(text)
  wait(20)
end
 end
 #--------------------------------------------------------------------------
 # * Show Removed State
 #	 target : Target
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_removed_states(target, obj = nil)
for state in target.removed_states
  next if state.message4.empty?
  text = target.name + state.message4
  @message_window.replace_instant_text(text)
  wait(20)
end
 end
 #--------------------------------------------------------------------------
 # * Show Unchanged State
 #	 target : Target
 #	 obj	: Skill or item
 #	Used when trying to put someone to sleep who is already asleep, etc.
 #--------------------------------------------------------------------------
 def display_remained_states(target, obj = nil)
for state in target.remained_states
  next if state.message3.empty?
  text = target.name + state.message3
  @message_window.replace_instant_text(text)
  wait(20)
end
 end
 #--------------------------------------------------------------------------
 # * Show Failure
 #	 target : Target (actor)
 #	 obj	: Skill or item
 #--------------------------------------------------------------------------
 def display_failure(target, obj)
text = sprintf(Vocab::ActionFailure, target.name)
@message_window.add_instant_text(text)
wait(20)
 end
end

Accendi la switch 41 quando vuoi la musica continua, altrimenti spegnila.

marigno · April 8, 2008

Problema risolto.

Chiudo.

Sign In

[RISOLTO] Impedire che la variabile torni a "nil" ad ogni avvio

Question

Link to comment

Share on other sites

12 answers to this question

Recommended Posts

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites