Belxebu

June 21, 2008

Non riesco ad utilizzarlo come intro...mi da vari errori...

June 19, 2008

Lavoro fatto ed inviato,aspetto conferma...

June 18, 2008

Da quanto ho capito dal PM che mi hai mandato sono riuscito a fare che quando attacca fa un passo avanti,fa animazione e poi torna indietro...

June 17, 2008

I personaggi non sono messi perfettamente allineati ed infatti un po vanno male ma se si mettono in ogni quadratino al centro dovrebbe essere perfetto ;) (io ho testato questo che ho fatto io senza quadratini e solo in alcuni frame si vedeva parte di gamba o di piede o di testa in un altro frame(mi pare fossero 3 o 4 frame sballati)

June 16, 2008

Ho creato questo semplice Template per facilitare la posizione dei vari frame:

http://img525.imageshack.us/img525/9044/templateragnarok8frame8zb6.png

May 10, 2008

Ingrandisce la risoluzione.In accoppiata con lo Sfondi VX di Synthesize rende possibile usare gli sfondi dell'XP...

May 9, 2008

Ho aggiornato il topic con la nuova versione come vi avevo promesso.Ho aggiornato anche con un nuovo screenshot.Ditemi che ne pensate...

EDIT Aggiotnato di nuovo.ho risolto un bug che si presentava con il BS standard

May 9, 2008

Ora sto tentando di fare una piccola modifica al menu in basso così che non si veda la striscia nera...ho quasi finito.a presto per lo script...

Ecco una prima anteprima della nuova versione:

May 9, 2008

Battle System Resolution XP

Descrizione

Uno script che riporterà il vostro BS alla grandezza di 640x480 per permettervi di usare sfondi stile RPGXP.(Compatibile con il BS Standard e con il BS di RPGTankentai(il Sideview).

Autore

Io

Script

#-------------------------------------------------------------------------------
# Battle System Resolution XP
# By Rinnegatamante
# 
# Uno script che riporterà il vostro BS alla grandezza di 640x480 
# per permettervi di usare sfondi stile RPGXP.
#
# Compatibilità:RPG Tankentai Sideview & BS Standard
#
# Per il corretto funzionamento di questo BS 
# utilizzare lo script "Sfondi Battaglie - RMVX" di Synthesize
#-------------------------------------------------------------------------------
#  PATCH PER UTILIZZATORI DEL "RPG Tankentai Sideview"
#
# Per utilizzarlo al meglio con il Sideview sostituire le stringhe 12 e 13
# del Modulo Sideview con queste stringhe:
#
#	GAME_SCREEN = [640, 480]
#  ACTOR_POSITION = [[511,182],[531,212],[551,242],[571,272]]
#
#  BUON DIVERTIMENTO!!!
#-------------------------------------------------------------------------------

#==============================================================================
# Sostituendo WIDTH e HEIGHT si può cambiare la risoluzione ma non si
# assicura il regolare funzionamento dello script.
#-------------------------------------------------------------------------------
WIDTH = 640
HEIGHT = 480
DELTA_WIDTH   = (WIDTH - 544).abs
DELTA_HEIGHT = (HEIGHT - 416).abs
#------------------------------------------------------------------------------
# ** Spriteset_Battle
#------------------------------------------------------------------------------
class Spriteset_Battle
 def create_viewports
@viewport1 = Viewport.new(0, 0, WIDTH, HEIGHT)
@viewport2 = Viewport.new(0, 0, WIDTH, HEIGHT)
@viewport3 = Viewport.new(0, 0, WIDTH, HEIGHT)
@viewport2.z = 50
@viewport3.z = 100
 end
end
#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  This window displays the status of all party members on the battle screen.
#==============================================================================

class Window_BattleStatus < Window_Selectable
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
super(0, 0, 512, 160)
refresh
self.active = false
 end
end
#==============================================================================
# ** Window_TargetEnemy
#------------------------------------------------------------------------------
#  Window for selecting the enemy who is the action target on the battle
# screen.
#==============================================================================

class Window_TargetEnemy < Window_Command
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
commands = []
@enemies = []
for enemy in $game_troop.members
  next unless enemy.exist?
  commands.push(enemy.name)
  @enemies.push(enemy)
end
super(513, commands, 2, 5)
 end
end
#==============================================================================
# ** 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
@message_window.height = 160
@message_window.width = 640
@message_window.y = 320
@message_window.x = 0
@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.resize_screen(640, 480)
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, 320, WIDTH, HEIGHT)
@info_viewport.z = 200
@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
@party_command_window.height = 160
@actor_command_window.height = 160
@actor_command_window.x = 640
@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
	$game_temp.map_bgm.play
	$game_temp.map_bgs.play
  end
  $scene = Scene_Map.new
  @message_window.clear
  Graphics.resize_screen(544, 416)
  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.height = 160
@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, 640, 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, 640, 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
RPG::BGM.stop
$game_system.battle_end_me.play
unless $BTEST
  $game_temp.map_bgm.play
  $game_temp.map_bgs.play
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

Screenshot

http://img379.imageshack.us/img379/9117/bsrxppz6.png

Istruzioni per l'uso

#-------------------------------------------------------------------------------
# Battle System Resolution XP
# By Rinnegatamante
# 
# Uno script che riporterà il vostro BS alla grandezza di 640x480 
# per permettervi di usare sfondi stile RPGXP.
#
# Compatibilità:RPG Tankentai Sideview & BS Standard
#
# Per il corretto funzionamento di questo bs 
# utilizzrae lo script "Sfondi Battaglie - RMVX" di Synthesize
#-------------------------------------------------------------------------------
#  PATCH PER UTILIZZATORI DEL "RPG Tankentai Sideview"
#
# Per utilizzarlo al meglio con il Sideview sostituire le stringhe 12 e 13
# del Modulo Sideview con queste stringhe:
#
#	GAME_SCREEN = [640, 480]
#  ACTOR_POSITION = [[511,182],[531,212],[551,242],[571,272]]
#
#  BUON DIVERTIMENTO!!!
#-------------------------------------------------------------------------------

May 8, 2008

Ragazzi,inizio un altro nuovo lavoro per chi lo volesse...posso convertire script da XP a VX(finche è nelle mie conoscenze di conversione....)...intanto gli altri lavori ci sono sempre...

May 5, 2008

Invece ho modificato 1 cosa sola precisamente...una Class che prima c'era in piu ovvero c'era ma non funzionava...e per giunta se provate a fare un evento cambia armi o cose del genere forse non funziona se non funziona ho fatto un'altra piccola versione senza un'altra classe...

May 4, 2008

il title dice 3D in RPG Maker 2003...

May 4, 2008

Ditemi come ha fatto e cosa usa 0_0...sembra FF VIII!!

April 21, 2008

sisi,li ho convertiti io e testati io sul mio progetto.

April 20, 2008

Face Save Menu V.1.0

Descrizione

Al posto dei Chara ci saranno i Face nel Save Menu

Autore

Rinnegatamante(Io,il mio primo script :D)

Istruzioni per l'uso

Sostituite Window_SaveFile con lo script.I face andranno nella cartella Graphics/Pictures e si chiameranno $nome chara personaggio per esempio se il chara di un eroe di nome Leon si chiamerà leonida,il suo face sarà $leonida(è consigliato non sorpassare 96x96 di grandezza

#==============================================================================
# ** Window_SaveFile
#------------------------------------------------------------------------------
#  This window displays save files on the save and load screens.
#==============================================================================
#--------------------------------------------------------
class Window_Base < Window
def draw_actor_face_graphic(actor, x, y)
 bitmap = Cache.face(actor)
 cw = bitmap.width
 ch = bitmap.height
 src_rect = Rect.new(0, 0, cw, ch)
self.contents.blt(x - cw/2, y - ch/2, bitmap, src_rect)
end
end
class Window_SaveFile < Window_Base
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader   :filename				 # filename
 attr_reader   :file_exist			   # file existence flag
 attr_reader   :time_stamp			   # timestamp
 attr_reader   :selected				 # selected
 #--------------------------------------------------------------------------
 # * Object Initialization
 #	 file_index : save file index (0-3)
 #	 filename   : filename
 #--------------------------------------------------------------------------
 def initialize(file_index, filename)
super(0, 56 + file_index % 4 * 90, 544, 290)
@file_index = file_index
@filename = filename
load_gamedata
refresh
@selected = false
 end
 #--------------------------------------------------------------------------
 # * Load Partial Game Data
 #	By default, switches and variables are not used (for expansion use,
 #	such as displaying place names)
 #--------------------------------------------------------------------------
 def load_gamedata
@time_stamp = Time.at(0)
@file_exist = FileTest.exist?(@filename)
if @file_exist
  file = File.open(@filename, "r")
  @time_stamp = file.mtime
  begin
	@characters	 = Marshal.load(file)
	@frame_count	= Marshal.load(file)
	@last_bgm	   = Marshal.load(file)
	@last_bgs	   = Marshal.load(file)
	@game_system	= Marshal.load(file)
	@game_message   = Marshal.load(file)
	@game_switches  = Marshal.load(file)
	@game_variables = Marshal.load(file)
	@total_sec = @frame_count / Graphics.frame_rate
  rescue
	@file_exist = false
  ensure
	file.close
  end
end
 end
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
self.contents.clear
self.contents.font.color = normal_color
name = Vocab::File + " #{@file_index + 1}"
self.contents.draw_text(4, 0, 400, WLH, name)
@name_width = contents.text_size(name).width
if @file_exist
  draw_party_characters(2002, 1008)
  draw_playtime(0, 34, contents.width - 4, 2)
end
 end
 #--------------------------------------------------------------------------
 # * Draw Party Characters
 #	 x : Draw spot X coordinate
 #	 y : Draw spot Y coordinate
 #--------------------------------------------------------------------------
 def draw_party_characters(x, y)
for i in 0...@characters.size
  for i in 0...@characters.size
 x = 150 + i * 70
 draw_actor_face_graphic ("$" + @characters[i][0], x, 30)
  end
 #--------------------------------------------------------------------------
 # * Draw Play Time
 #	 x : Draw spot X coordinate
 #	 y : Draw spot Y coordinate
 #	 width : Width
 #	 align : Alignment
 #--------------------------------------------------------------------------
 def draw_playtime(x, y, width, align)
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
self.contents.font.color = normal_color
self.contents.draw_text(x, y, width, WLH, time_string, 2)
 end
 #--------------------------------------------------------------------------
 # * Set Selected
 #	 selected : new selected (true = selected, false = unselected)
 #--------------------------------------------------------------------------
 def selected=(selected)
@selected = selected
update_cursor
 end
 #--------------------------------------------------------------------------
 # * Update cursor
 #--------------------------------------------------------------------------
 def update_cursor
if @selected
  self.cursor_rect.set(0, 0, @name_width + 8, WLH)
else
  self.cursor_rect.empty
 end
  end
 end
end
end

Bugs e Conflitti Noti

Purtroppo non è compatibile con lo script dei 99 Salvataggi(Taglia alcuni face troppo grandi se si usa anche questo script)

Screenshot

http://img379.imageshack.us/img379/7434/facesavemeniumv9.png

April 20, 2008

Se ancora non risolvi ho postato uno script che inserice un ABS,magari ti funziona ed usi quello...

April 20, 2008

Prima c'era un problemino con alcuni script,ora l'ho risolto,enjoy ^^

April 20, 2008

Leon's Good and Evil Script

Descrizione

Inserisce nello status di ogni personaggio una barra che mostra l'allineamento dell'eroe.Anche questo è un vecchio script per XP che ho riadattato per il VX.RICHIEDE LA TOTAL CONVERSION.

Autore

Leon adattato da Rinnegatamante

Istruzioni per l'uso

Inserire sotto la Total Conversion.Per aumentare e diminuire punti leggere l'inizio dello script.

#===================================
# Leon's Good and Evil script adattato da Rinnegatamante
#----------------------------------------------------------------------
# Features:
# Gives an actor the "good", "Neutral" or "evil" alignment, based
# upon their actions.
#
# Instructions:
# Place above main, and below other scripts.
# Use: draw_alignment_bar(actor, x, y) in a script to draw the alignment bar.
# x and y being the position of the bar, and actor being the syntax for the actor's information.
#
# To use:
# To add or subtract from their alignment, use: $game_actors[actor_id].alignment += x
# To see if the actor's alignment is good, evil or neutral, use:
# * Conditional Branch, tab 4, Script.
# * For good, use $game_actors[actor_id] > 0
# * For evil, use $game_actors[actor_id] < 0
# * For neutral, use $game_actors[actor_id] == 0
#
# Extra Information:
# This script edits the original Window_Status script to add the good/evil.
#===================================

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Game_Actor
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Game_Actor < Game_Battler

attr_accessor :alignment
attr_accessor :alignment_name

alias leon_alignment_bars_ga_setup setup

def setup(actor_id)
@alignment = 0
@alignment_name = "Neutrale"
leon_alignment_bars_ga_setup(actor_id)
end

def alignment
if @alignment > 0
if @alignment > 100
@alignment = 100
end
@alignment_name = "Buono"
return @alignment
end
if @alignment < 0
if @alignment < -100
@alignment = -100
end
@alignment_name = "Cattivo"
return @alignment
end
@alignment_name = "Neutrale"
return @alignment
end


end

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Window_Base
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Window_Base
def draw_bar(x, y, min, max, width = 152, height = 6,
bar_color = Color.new(0, 75, 0, 255), end_color = Color.new(0, 255, 0, 255))
for i in 0..height
self.contents.fill_rect(x + i, y + height - i, width + 1, 1, Color.new(50, 50, 50, 255))
end
for i in 1..(height - 1)
r = 100 * (height - i) / height + 0 * i / height
g = 100 * (height - i) / height + 0 * i / height
b = 100 * (height - i) / height + 0 * i / height
a = 255 * (height - i) / height + 255 * i / height
self.contents.fill_rect(x + i, y + height - i, width, 1, Color.new(r, b, g, a))
end
for i in 1..( (min.to_f / max.to_f) * width - 1)
for j in 1..(height - 1)
r = bar_color.red * (width - i) / width + end_color.red * i / width
g = bar_color.green * (width - i) / width + end_color.green * i / width
b = bar_color.blue * (width - i) / width + end_color.blue * i / width
a = bar_color.alpha * (width - i) / width + end_color.alpha * i / width
self.contents.fill_rect(x + i + j, y + height - j, 1, 1, Color.new(r, g, b, a))
end
end
end

def draw_backward_bar(x, y, min, max, width = 152, height = 6,
bar_color = Color.new(75, 0, 0, 255), end_color = Color.new(255, 0, 0, 255))
for i in 0..height
self.contents.fill_rect(x + i, y + height - i, width + 1, 1, Color.new(50, 50, 50, 255))
end
for i in 1..(height - 1)
r = 100 * (height - i) / height + 0 * i / height
g = 100 * (height - i) / height + 0 * i / height
b = 100 * (height - i) / height + 0 * i / height
a = 255 * (height - i) / height + 255 * i / height
self.contents.fill_rect(x + i, y + height - i, width, 1, Color.new(r, b, g, a))
end
for i in 1..( (min.to_f / max.to_f) * width - 1)
for j in 1..(height - 1)
r = bar_color.red * (width - i) / width + end_color.red * i / width
g = bar_color.green * (width - i) / width + end_color.green * i / width
b = bar_color.blue * (width - i) / width + end_color.blue * i / width
a = bar_color.alpha * (width - i) / width + end_color.alpha * i / width
self.contents.fill_rect(x - i + j, y + height - j, 1, 1, Color.new(r, g, b, a))
end
end
end

def draw_alignment_bar(actor, x, y)
#x = 320 y = 147
draw_bar(x, y, 0, 200, 200, 6)
if actor.alignment > 0
draw_bar(x + 100, y, actor.alignment, 100, 100, 6)
actor.alignment_name = "Buono"
elsif actor.alignment < 0
draw_backward_bar(x + 100, y, -1 * actor.alignment, 100, 100, 6)
actor.alignment_name = "Cattivo"
elsif actor.alignment == 0
draw_bar(x + 100, y, actor.alignment, 100, 100, 6)
actor.alignment_name = "Neutrale"
end
draw_bar(x + 97, y - 2, 2, 2, 2, 10, Color.new(255, 255, 255, 255), Color.new(255, 255, 255,255))
end

end


#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Window_Status
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Window_Status < Window_Base

alias leon_alignment_bars_ws_refresh refresh

def refresh
leon_alignment_bars_ws_refresh
if @actor.alignment > 100
@actor.alignment = 100
elsif @actor.alignment < -100
@actor.alignment = -100
end
self.contents.font.color = system_color
self.contents.draw_text(290, 122, 120, 32, "Carattere")
draw_alignment_bar(@actor, 280, 157)
self.contents.font.color = normal_color
self.contents.draw_text(380, 122, 120, 32, @actor.alignment_name)
end
end

April 20, 2008

Window_HUD

Descrizione

Un bellissimo HUD,script riadattato da uno vecchio per l'XP.RICHIEDE LA TOTAL CONVERSION

Autore

Rinnegatamante(ovvero io,lo script reale non so di chi sia)

Allegati

http://img155.imageshack.us/img155/5398/hudgraphiczx7.png

http://img166.imageshack.us/img166/9620/hudgraphic1aj4.png

http://img166.imageshack.us/img166/4182/hudgraphic2dx6.png

http://img155.imageshack.us/img155/9849/hudgraphic3lh9.png

http://rapidshare.com/files/108916679/System.rar.html

Istruzioni per l'uso

Copiate le 4 immagini qui sopra in Graphics/Pictures chiamandole in seguenza hud graphic,hud graphic1,hud graphic2,hud graphic3,le tre icone presenti nell'archivio da scaricare invece vanno in Graphics/System e copiate il codice sotto la total conversion.

#==============================================================================
# ** Window_HUD modificato e adattato da Rinnegatamante
#------------------------------------------------------------------------------
# This class is used to display HP, SP and Gold on the map.
#==============================================================================
class Window_HUD < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(-16, -16, 672, 150)
self.contents = Bitmap.new(width-32, height-32)
self.opacity = 0
self.contents.font.size = 14
self.contents.font.name = "Monotype Corsiva"
@actors = []
@old_hp = []
@old_sp = []
@old_exp = []
@old_level = []
for i in 0...$game_party.actors.size
@actors.push($game_party.actors[i])
@old_hp.push(@actors[i].hp)
@old_sp.push(@actors[i].sp)
@old_exp.push(@actors[i].now_exp)
@old_level.push(@actors[i].level)
end
@old_gold = $game_party.gold
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = system_color
#self.contents.draw_text(6, 0, 32, 14, $data_system.words.hp + "")
#self.contents.draw_text(6, 14, 32, 14, $data_system.words.sp + "")
self.contents.draw_text(6, 28, 32, 14, "")
#self.contents.draw_text(6, 42, 32, 14, $data_system.words.gold + "")
self.contents.font.color = normal_color
#Images

case @actors.size
when 1
bitmap = Cache.picture("HUD Graphic")
self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 500, 500))
when 2
bitmap = Cache.picture("HUD Graphic2")
self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 500, 500))
when 3
bitmap = Cache.picture("HUD Graphic2")
self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 500, 500))
when 4
bitmap = Cache.picture("HUD Graphic3")
self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 640, 500))
when 5
bitmap = Cache.picture("HUD Graphic3")
self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 640, 500))
end

#bitmap = Cache.picture("HUD Graphic")
#self.contents.blt(0, 0, bitmap, Rect.new(0, 10, 500, 500))
bitmap = Cache.icon("HP Symbol")
self.contents.blt(0, 15, bitmap, Rect.new(0, 0, 28, 24))
bitmap = Cache.icon("SP Symbol")
self.contents.blt(0, 35, bitmap, Rect.new(0, 0, 24, 24))
bitmap = Cache.icon("EXP Symbol")
self.contents.blt(-5, 55, bitmap, Rect.new(0, 0, 37, 24))
bitmap = Cache.icon("Hero")
self.contents.blt(25, 67, bitmap, Rect.new(0, 0, 24, 24))

if $game_switches[99] == true
if $game_variables[99] == 0
self.contents.draw_text(x, y, 210, 14, $game_party.item_number[1])
elsif $game_variables[8] == 1
 self.contents.draw_text(x, y, 210, 14, $game_party.item_number(2))
elsif $game_variables[8] ==2
 self.contents.draw_text(x, y, 110, 14, @actors[i].name)
end
end
x = 32
for i in 0...@actors.size
y = 6
self.contents.draw_text(x, y, 110, 14, @actors[i].name)
self.contents.draw_text(x, y, 110, 14, "Lv: #{@actors[i].level}", 2)
y += 16
draw_hp_bar(@actors[i], x, y, 112, 5)
y += 19
draw_sp_bar(@actors[i], x, y, 104, 5)
y += 19
draw_exp_bar(@actors[i], x, y, 88, 5)
y += 19
x += 130
end
x = 32
self.contents.draw_text(40, 73, 110, 14, $game_party.gold.to_s)
self.contents.draw_text(75, 73, 110, 14, "Guil")
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
if @actors.size != $game_party.actors.size
@actors = []
for i in 0...$game_party.actors.size
@actors.push($game_party.actors[i])
end
refresh
return
end
for i in 0...@actors.size
if @old_hp[i] != @actors[i].hp or
@old_sp[i] != @actors[i].sp or
@old_exp[i] != @actors[i].now_exp or
@old_level[i] != @actors[i].level or
@old_gold != $game_party.gold
refresh
@old_hp[i] = @actors[i].hp
@old_sp[i] = @actors[i].sp
@old_exp[i] = @actors[i].now_exp
@old_level[i] = @actors[i].level
@old_gold = $game_party.gold
end
end
end
#--------------------------------------------------------------------------
# * Draw HP Bar
#--------------------------------------------------------------------------
def draw_hp_bar(actor, x, y, length, thick)
width = length
height = thick
c1 = Color.new(255, 0, 0)
c2 = Color.new(155, 0, 0)
e1 = actor.hp
e2 = actor.maxhp
self.contents.fill_rect(x-1, y - 1, width+2, height + 3, Color.new(255, 255, 255, 255))
self.contents.fill_rect(x, y, width, height + 1, Color.new(0, 0, 0, 255))
w = width * e1 / e2
for i in 0..height
r = c1.red + (c2.red - c1.red) * (height -i)/height + 0 * i/height
g = c1.green + (c2.green - c1.green) * (height -i)/height + 0 * i/height
b = c1.blue + (c2.blue - c1.blue) * (height -i)/height + 0 * i/height
a = c1.alpha + (c2.alpha - c1.alpha)* (height -i)/height + 255 * i/height
self.contents.fill_rect(x, y+i, w, 1, Color.new(r, g, b, a))
end
end
#--------------------------------------------------------------------------
# * Draw SP Bar
#--------------------------------------------------------------------------
def draw_sp_bar(actor, x, y, length, thick)
width = length
height = thick
c1 = Color.new(0, 0, 255)
c2 = Color.new(0, 0, 155)
e1 = actor.mp
e2 = actor.maxmp
self.contents.fill_rect(x-1, y - 1, width+2, height + 3, Color.new(255, 255, 255))
self.contents.fill_rect(x, y, width, height + 1, Color.new(0, 0, 0))
w = width * e1 / e2
for i in 0..height
r = c1.red + (c2.red - c1.red) * (height -i)/height + 0 * i/height
g = c1.green + (c2.green - c1.green) * (height -i)/height + 0 * i/height
b = c1.blue + (c2.blue - c1.blue) * (height -i)/height + 0 * i/height
a = c1.alpha + (c2.alpha - c1.alpha)* (height -i)/height + 255 * i/height
self.contents.fill_rect(x, y+i, w, 1, Color.new(r, g, b, a))
end
end
#--------------------------------------------------------------------------
# * Draw EXP Bar
#--------------------------------------------------------------------------
def draw_exp_bar(actor, x, y, length, thick)
width = length
height = thick
c1 = Color.new(158, 208, 9)
c2 = Color.new(58, 108, 0)
e1 = actor.now_exp
e2 = actor.next_exp
if actor.next_exp == 0
e1 = 1
e2 = 1
end
self.contents.fill_rect(x-1, y - 1, width+2, height + 3, Color.new(255, 255, 255, 255))
self.contents.fill_rect(x, y, width, height + 1, Color.new(0, 0, 0, 255))
w = width * e1 / e2
for i in 0..height
r = c1.red + (c2.red - c1.red) * (height -i)/height + 0 * i/height
g = c1.green + (c2.green - c1.green) * (height -i)/height + 0 * i/height
b = c1.blue + (c2.blue - c1.blue) * (height -i)/height + 0 * i/height
a = c1.alpha + (c2.alpha - c1.alpha)* (height -i)/height + 255 * i/height
self.contents.fill_rect(x, y+i, w, 1, Color.new(r, g, b, a))
end
end
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
# This class performs map screen processing.
#==============================================================================
class Scene_Map
#--------------------------------------------------------------------------
# * Object Aliasing
#--------------------------------------------------------------------------
alias hud_scene_map_main main
alias hud_scene_map_update update
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def main
@HUD = Window_HUD.new
hud_scene_map_main
@HUD.dispose
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
@HUD.update
hud_scene_map_update
end
end

Screenshot

http://img253.imageshack.us/img253/471/hudscreentw4.png

April 20, 2008

MINTO Special Transition Versione VX

Descrizione

Uno script che cambia l'effetto prodotto quando si incontra un mostro.Se impostato con belle immagini da davvero un bell'effetto.RICHIEDE LA TOTAL CONVERSION E IL MODULO MINTO!

Autore

Minto(Versione XP),io(Versione VX)

Istruzioni per l'uso

Mettete l'immagine da usare come Transition nella cartella Graphics\Pictures e chiamatela Warp(è consigliato non sorpassare i 640x480 di grandezza) poi copiate il seguente script SOTTO IL MODULO MINTO

################################################
#		 MINTO Special Transition  ver VX	  #
#################################################
#   by Rinnegatamante						   #
#   by Minto									# 
#################################################
=begin  (Tradução(PT) e Tutorial By Moghunter)  

CARACTERÍSTICAS 
 Adiciona efeito especial na transição da batalha.

UTILIZAÇÃO
  É necessário ter uma imagem de 640x480 na pasta
 Graphics/Pictures/  nomeado com o nome de "WARP" 
=end
module MINTO
 RGSS["Battle_Effect"] = true
end
if MINTO::RGSS["Battle_Effect"]
module MINTO  
 #Definição do nome da imagem de transição.  
 Battle_Effect_Picture = "Warp"
 #Som ao executar a transição
 Battle_Effect_SE_Date = ["009-System09", 100, 50]  
end
#-------------------------------------------------#
class Scene_Map
 alias main_Battle_Effect main
 def main
@scene_sprite = Sprite.new
main_Battle_Effect
@scene_sprite.dispose
 end  
 def battle_effect	
@scene_sprite.bitmap = Bitmap.new(640, 480)
@scene_sprite.z = 999
file = Cache.picture(MINTO::Battle_Effect_Picture)
thyme = 40
data = MINTO::Battle_Effect_SE_Date
Audio.se_play("Audio/SE/#{data[0]}", data[1], data[2])
while thyme > 0
  thyme -= 1
  width = (file.width * thyme) / 40
  height = (file.height * thyme) / 40
  x = (544 - width)
  y = (416 - height) / 2
  dest_rect = Rect.new(x, y, width, height)
  @scene_sprite.bitmap.stretch_blt(dest_rect, file, file.rect, 60)
  Graphics.update
  @scene_sprite.update
end
thyme = 40
while thyme > 0
  thyme -= 1
  width = (file.width * thyme) / 40
  height = (file.height * thyme) / 40
  x = width
  y = 0
  dest_rect = Rect.new(x, y, width, height)
  @scene_sprite.bitmap.stretch_blt(dest_rect, file, file.rect, 60)
  Graphics.update
  @scene_sprite.update
end
 end
 alias call_battle_Battle_Effect call_battle
 def call_battle
battle_effect
call_battle_Battle_Effect
 end
end
end

April 20, 2008

Modulo Minto Versione VX

Descrizione

Il modulo Minto che ho completamente ricorretto per farlo funzionare su RPG Maker VX dotato di Total Conversion.Il modulo Minto permette a tutti i mod creati da Minto di poter funzionare(ovviamente se sono conversibili con VX)RICHIEDE LA TOTAL CONVERSION.

Autore

MINTO(Versione XP),io(Versione VX)

Istruzioni per l'uso

Copiare sotto la Total Conversion

#################################################
#		   MODULO MESTRE  ver VX			   #
#################################################
#   by Rinnegatamante						   #
#   by Minto									#
#################################################
module MINTO
 RGSS = {}
end
class Game_Enemy < Game_Battler  
 def equip?(type = 0)
return false
 end
end
module Data_Actors
 def self.initialize(in_battle = false)
if in_battle
  data = load_data("Data/BT_Actors.rvdata")
else
  data = load_data("Data/Actors.rvdata")
end	
@data = data
 end
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module Data_Classes
 def self.initialize(in_battle = false)
if in_battle
  data = load_data("Data/BT_Classes.rvdata")
else
  data = load_data("Data/Classes.rvdata")
end	
@data = data
 end
 def self.data
return @data
 end
end
module Data_Weapons
 def self.initialize(in_battle = false)
if in_battle
  data_weapons = load_data("Data/BT_Weapons.rvdata")
else
  data_weapons = load_data("Data/Weapons.rvdata")
end	
@data = data_weapons
 end
 def self.data
return @data
 end
end
module Data_Armors
 def self.initialize(in_battle = false)
if in_battle
  data = load_data("Data/BT_Armors.rvdata")
else
  data = load_data("Data/Armors.rvdata")
end	
@data = data
 end
 def self.data
return @data
 end
end
module Data_Items
 def self.initialize(in_battle = false)
if in_battle
  data = load_data("Data/BT_Items.rvdata")
else
  data = load_data("Data/Items.rvdata")
end	
@data = data
 end
 def self.data
return @data
 end
end
module Data_System
 def self.initialize(in_battle = false)
if in_battle
  data = load_data("Data/BT_System.rvdata")
else
  data = load_data("Data/System.rvdata")
end	
@data = data
 end
 def self.data
return @data
 end
end
module Data_Skills_Base
 def self.initialize(in_battle = false)
if in_battle
  data_skills = load_data("Data/BT_Skills.rvdata")
else
  data_skills = load_data("Data/Skills.rvdata")
end	
@data = data_skills
 end
 def self.data
return @data
 end
end
module Data_Troops
 def self.initialize(in_battle = false)
if in_battle
  data_troops = load_data("Data/BT_Troops.rvdata")
else
  data_troops = load_data("Data/Troops.rvdata")
end	
@data = data_troops
 end
 def self.data
return @data
 end
end
module Data_Enemies
 def self.initialize(in_battle = false)
if in_battle
  data_enemies = load_data("Data/BT_Enemies.rvdata")
else
  data_enemies = load_data("Data/Enemies.rvdata")
end
@data = data_enemies
 end
 def self.data
return @data
 end
end
module Data_States
 def self.initialize(in_battle = false)
if in_battle
  data_states = load_data("Data/BT_States.rvdata")
else
  data_states = load_data("Data/States.rvdata")
end
@data = data_states
 end
 def self.data
return @data
 end
end
module Data_Animations
 def self.initialize(in_battle = false)
if in_battle
  data_animations = load_data("Data/BT_Animations.rvdata")
else
  data_animations = load_data("Data/Animations.rvdata")
end	
@data = data_animations
 end
 def self.data
return @data
 end
end
module Data_Common_Events
 def self.initialize(in_battle = false)
if in_battle
  data_common_events = load_data("Data/BT_CommonEvents.rvdata")
else
  data_common_events = load_data("Data/CommonEvents.rvdata")
end
@data = data_common_events
 end
 def self.data
return @data
 end
end
module Data_Map
 def self.initialize(data = nil)
if !data
  @data = Game_Map.new
else
  @data = data
end	
 end
 def self.data
return @data
 end
end
module RPG_System
 def self.initialize(data = nil)
if !data
  @data = Game_System.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Temp
 def self.initialize(data = nil)
if !data
  @data = Game_Temp.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Switches
 def self.initialize(data = nil)
if !data
  @data = Game_Switches.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Variables
 def self.initialize(data = nil)
if !data
  @data = Game_Variables.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_SelfSwitches
 def self.initialize(data = nil)
if !data
  @data = Game_SelfSwitches.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Screen
 def self.initialize(data = nil)
if !data
  @data = Game_Screen.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Actors
 def self.initialize(data = nil)
if !data
  @data = Game_Actors.new
else
  @data = data
end	
 end
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Party
 def self.initialize(data = nil)
if !data
  @data = Game_Party.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Troop
 def self.initialize(data = nil)
if !data
  @data = Game_Troop.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module RPG_Player
 def self.initialize(data = nil)
if !data
  @data = Game_Player.new
else
  @data = data
end	
 end  
 def self.data=(data)
@data = data
 end
 def self.data
return @data
 end
end
module MINTO
 def self.set_up_data_module(test_battle = false)
if !Data_Actors::data
  Data_Actors::initialize(test_battle)
  Data_Classes::initialize(test_battle)
  Data_Items::initialize(test_battle)
  Data_Armors::initialize(test_battle)
  Data_System::initialize(test_battle)
  Data_Enemies::initialize(test_battle)
  Data_Troops::initialize(test_battle)
  Data_Weapons::initialize(test_battle)
  Data_Skills_Base::initialize(test_battle)
  Data_Animations::initialize(test_battle)
  Data_States::initialize(test_battle)
  Data_Common_Events::initialize(test_battle)
end
 end
 def self.set_up_game_object
RPG_Switches::initialize
RPG_Variables::initialize
RPG_SelfSwitches::initialize
RPG_Screen::initialize
RPG_Actors::initialize
RPG_Party::initialize
RPG_Troop::initialize
RPG_Player::initialize
Data_Map::initialize
 end
 def self.save_game_object(file)
Marshal.dump(RPG_System::data, file)
Marshal.dump(RPG_Switches::data, file)
Marshal.dump(RPG_Variables::data, file)
Marshal.dump(RPG_SelfSwitches::data, file)
Marshal.dump(RPG_Screen::data, file)
Marshal.dump(RPG_Actors::data, file)
Marshal.dump(RPG_Party::data, file)
Marshal.dump(RPG_Troop::data, file)
Marshal.dump(RPG_Player::data, file)
Marshal.dump(Data_Map::data, file)
 end
 def self.load_game_object(file)
RPG_System::initialize(Marshal.load(file))
RPG_Switches::initialize(Marshal.load(file))
RPG_Variables::initialize(Marshal.load(file))
RPG_SelfSwitches::initialize(Marshal.load(file))
RPG_Screen::initialize(Marshal.load(file))
RPG_Actors::initialize(Marshal.load(file))
RPG_Party::initialize(Marshal.load(file))
RPG_Troop::initialize(Marshal.load(file))
RPG_Player::initialize(Marshal.load(file))
Data_Map::initialize(Marshal.load(file))	
 end
end
MINTO.set_up_data_module($BTEST)

April 20, 2008

Ho un HUD di XP che grazie alla Total Conversion e qualche modifica mi funge anche su VX.Prima su XP per far si che premendo un tasto scompariva avevo messo in Scene_Map questo:

if Input.trigger?(Input::A)
 if @HUD.visible == true
  @HUD.visible = false
else
  @HUD.visible = true
end
end

e fungeva.Se lo metto anche sul VX invece non funziona e anche premendo il tasto l'HUD resta.Dove sbaglio??(l'RGSS2 è + mistico dell'RGSS :smile: )

April 20, 2008

Multiple Frame Title

Descrizione

Uno script per XP che grazie alla Total Conversion funge anche su VX,questo script permette di avere un menu principale con immagini a rotazione.

Autore

The Sleeping Leonhart

Istruzioni per l'uso

Inserite lo script

SOTTO

la Total Conversion,mettete in Pictures le immagini che dovranno roteare chiamandole title1,title2,title3 e cosi via.Le immagini devono essere 544x416 di grandezza

#===============================================================================

# Multiple Frame Title
# by The Sleeping Leonhart
#===============================================================================

class Scene_Title
alias tsl_scene_title_main main
def main
#==========================CONFIGURAZIONE==========================
@frame_number = 2 #Numero di frame
@title_name = "title" #Nome della picture
@wait = 300 #Tempo di attesa fra una picture e l'altra
#=================================================================
@frame = 2
@wait_count = 1
tsl_scene_title_main
end
alias tsl_scene_title_update update
def update
if @wait_count < @wait
@wait_count += 1
if @wait_count == @wait
if @frame < @frame_number+1
@sprite.bitmap.dispose
@sprite.dispose
@sprite = Sprite.new
@sprite.bitmap = Cache.picture(@title_name+@frame.to_s)
@wait_count = 1
if @frame == @frame_number
@frame = 0
end
end
@frame += 1
end
end
tsl_scene_title_update
end
end

April 20, 2008

Scene_Puzle

Descrizione

Il minigioco del puzzle,un vecchio script per l'XP che ho modificato e grazie alla Total Conversion funge anche su VX(RICHIEDE LA TOTAL CONVERSION)

Autore

DarkRog riadattato da me

Istruzioni per l'uso

Inserire 2 immagini(preferibilmente le stesse)di grandezza 420x420 da chiamare una Baxk e l'altra Puzle1 in Graphics/Pictures e inserire lo script

SOTTO

la Total Conversion,per richiamare lo script ci sono le istruzioni dentro lo script(un esempio di come avviare lo script:

$scene = Scene_Puzle.new(140, "Puzle1", 3, 30, "Back")

#==============================================================================
# ■ Scene_Puzle - By DarkRog - Versión Pase automático de piezas.
#  MODIFICATO E ADATTATO PER VX DA RINNEGATAMANTE
#You need a picture with size 420px x 420px, in Graphics/Pictures.
#You have to call a script from an event and write:
#$scene = Scene_Puzle.new(piece size , "picture", variable id (this variable will be the result of the game), time, background)
#*The size has to be dividing of 420.
#*The picture need to be in Graphics/Picture.
#*The variable id:
#1:You won, 2:Time up.
#*Seconds, or false for unlimited time.
#*A background image in Graphics/Picture, or false for any picture.
#Example:
#$scene = Scene_Puzle.new(140, "Puzle1", 3, 30, "Back")
#Size:140, Picture:"Puzle1", Variable:3, Seconds:30 Background:"Back".
#------------------------------------------------------------------------------

class Scene_Puzle
def initialize(size, img, vid, tim, back)
@pu = Window_Puzle.new(size, img, vid, tim, back)
end
def main
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@pu.dispose
if $scene.is_a?(Scene_Title)
Graphics.transition
Graphics.freeze
end
end
def update
@pu.refresh
end
end

class Window_Puzle < Window_Base
def initialize(size, img, vid, tim, back)
super(-16, -16, 640+32, 480+32)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = 20
@back = back
@vid = vid
@piezasi = size
@img = img
@winb = Window_PBrillo.new
if tim == false
@timeh = false
else
@time = tim*25
@timeh = true
end
@pieza = []
piezas = []
num = 0
for i in 0..420/@piezasi-1
for a in 0..420/@piezasi-1
@pieza[num] = Pieza_Puzle.new(a, i)
piezas[num] = num
num += 1
end
end
@op = []
for i in 0..420/@piezasi*420/@piezasi-1
loop do
ra = rand(420/@piezasi*420/@piezasi)
if piezas[ra] != nil
@op[i] = ra
piezas[ra] = nil
break
end
end
end
@cursor = num-1
@o = 100
@re = false
refresh
end
def refresh
self.contents.clear
$fontface = "Monotype Corsiva"
$fontsize = 24
if @back != false
self.contents.blt(0, 0, Cache.picture(@back), Rect.new(0, 0, 640, 480), 255)
end
if @timeh == true
@time -= 1
if @time == 0
$game_variables[@vid] = 2
$game_system.se_play($data_system.buzzer_se)
$scene = Scene_Map.new
end
end
if @o <= 100
@re = false
elsif @o >= 255
@re = true
end
if @re == false
@o += 5
elsif @re == true
@o -= 5
end
self.contents.draw_text(26, 0, 640, 32, "Pezzi")
self.contents.font.name = "Monotype Corsiva"
self.contents.font.size = 24
self.contents.draw_text(300, 0, 640, 32, "Pannello")
self.contents.font.name = "Monotype Corsiva"
self.contents.font.size = 24
if @timeh != false
if @time/25%60 > 9
self.contents.draw_text(460, 0, 640, 32, "Tempo: #{@time/25/60}:#{@time/25%60}")
self.contents.font.name = "Monotype Corsiva"
self.contents.font.size = 24
else
self.contents.draw_text(460, 0, 640, 32, "Tempo: #{@time/25/60}:0#{@time/25%60}")
self.contents.font.name = "Monotype Corsiva"
self.contents.font.size = 24
end
else
self.contents.draw_text(420, 0, 640, 32, "Tempo Illimitato")
self.contents.font.name = "Monotype Corsiva"
self.contents.font.size = 24
end
self.contents.fill_rect(70-@piezasi/2+@piezasi/100, 240-@piezasi/2, @piezasi+2, @piezasi+2, Color.new(0, 0, 0, 200))
self.contents.fill_rect(175, 35, 422, 422, Color.new(0, 0, 0, 200))
self.contents.blt(176, 36, Cache.picture(@img), Rect.new(0, 0, 420, 420), 10)
pieza = 0
for i in 0..420/@piezasi-1
for a in 0..420/@piezasi-1
if @pieza[pieza].d == true
self.contents.blt(176+a*@piezasi, 36+i*@piezasi, Cache.picture(@img), Rect.new(@piezasi*a, @piezasi*i, @piezasi, @piezasi), 255)
end
pieza += 1
end
end
for a in -1..1
i = @cursor-a
if @op[i] != nil
if i >= 0 and a != 0
if @pieza[@op[i]].d == false
elsif @pieza[@op[i]].d == true
end
end
if a == 0
if @pieza[@op[i]].d == false
self.contents.blt(70-@piezasi/2+@piezasi/100+1, 240-@piezasi*3/2+@piezasi*(a+1), Cache.picture(@img), Rect.new(@pieza[@op[i]].x*@piezasi, @pieza[@op[i]].y*@piezasi, @piezasi, @piezasi), @o)
elsif @pieza[@op[i]].d == true
self.contents.blt(70-@piezasi/2+@piezasi/100+1, 240-@piezasi*3/2+@piezasi*(a+1), Cache.picture(@img), Rect.new(@pieza[@op[i]].x*@piezasi, @pieza[@op[i]].y*@piezasi, @piezasi, @piezasi), 20+@o/10)
end
end
end
end
if @fase == 1
f1_up
return
elsif @fase == nil
@fase = 1
@cursorx = 0
@cursory = 0
end
end


def f1_up
self.contents.blt(@piezasi*@cursorx+176, 36+@piezasi*@cursory, Cache.picture(@img), Rect.new(@pieza[@op[@cursor]].x*@piezasi, @pieza[@op[@cursor]].y*@piezasi, @piezasi, @piezasi), @o)
if Input.repeat?(Input::RIGHT) and @cursorx < 420/@piezasi-1
@cursorx += 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::RIGHT) and @cursorx == 420/@piezasi-1
$game_system.se_play($data_system.cursor_se)
@cursorx = 0
end
if Input.repeat?(Input::LEFT) and @cursorx > 0
@cursorx -= 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::LEFT) and @cursorx == 0
$game_system.se_play($data_system.cursor_se)
@cursorx = 420/@piezasi-1
end
if Input.repeat?(Input::DOWN) and @cursory < 420/@piezasi-1
@cursory += 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::DOWN) and @cursory == 420/@piezasi-1
@cursory = 0
$game_system.se_play($data_system.cursor_se)
end
if Input.repeat?(Input::UP) and @cursory >0
@cursory -= 1
$game_system.se_play($data_system.cursor_se)
elsif Input.repeat?(Input::UP) and @cursory == 0
@cursory = 420/@piezasi-1
$game_system.se_play($data_system.cursor_se)
end
if Input.trigger?(Input::C)
if @pieza[@op[@cursor]].x == @cursorx and @pieza[@op[@cursor]].y == @cursory
$game_system.se_play($data_system.load_se)
@pieza[@op[@cursor]].d = true
piezac = 0
for i in 0...420/@piezasi*420/@piezasi
if @pieza[i].d == true
piezac +=1
end
end
if piezac == 420/@piezasi*420/@piezasi
$game_variables[@vid] = 1
@o2 = 0
@re2 = false
@t2 = 0
Audio.se_play("Audio/SE/056-Right02.ogg", 100, 50)
loop do
Graphics.update
@t2 += 1
if @re2 == true
@o2 -= 5
elsif @re2 == false
@o2 += 5
end
if @o2 >= 255
@re2 = true
elsif @o2 <= 0
@re2 = false
end
@winb.refresh(@o2)
if @t2 == 102
@winb.dispose
break
end
end
$game_system.se_play($data_system.shop_se)
$scene = Scene_Map.new
else
@cursor -= 1
end
else
$game_system.se_play($data_system.buzzer_se)
end
return
end
end

end

class Pieza_Puzle
attr_accessor :x
attr_accessor :y
attr_accessor :d
def initialize(x, y)
@x = x
@y = y
@d = false
end
end

class Window_PBrillo < Window_Base
def initialize
super(-16, -16, 640+32, 480+32)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = 20
self.opacity = 0
refresh(0)
end
def refresh(o)
self.contents.clear
$fontsize == 24
$fontface == "Monotype Corsiva"
self.contents.fill_rect(175, 35, 422, 422, Color.new(255, 255, 255, o))
end
end

April 20, 2008

Si,in pratica è questo infatti riemula le vecchie funzioni dell'XP,del mio vecchio prog per XP funzionano tre script per ora:Light Effects(quello per fare la luce)che però sballa la posizione della luce in quanto il VX ha la risoluzione piu piccola(l'XP se non erro aveva anche lo schermo piu grande),quello del Puzzle che mi funziona anche meglio del XP e Multiple Frame Title di The Sleeping Leonhart(yuuuhuuu XD)che permette di fare uno Scene_Title con immagini a rotazione,oggi vedo se va qualcos'altro...

Sign In

Belxebu

Posts

Joined

Last visited

Content Type

Profiles

Forums

Calendar

Posts posted by Belxebu

-Mog Scene Story V1.0

La bottega principale[RGSS e Eventi]

La bottega principale[RGSS e Eventi]

Template Chara Ragnarok 8 Frame 8 Direzioni

Template Chara Ragnarok 8 Frame 8 Direzioni

Battle System Resolution XP

Battle System Resolution XP

Battle System Resolution XP

Battle System Resolution XP

La bottega principale[RGSS e Eventi]

Total Conversion VX to XP

3d In RPG Maker 2003

3d In RPG Maker 2003

MINTO Special Transition

Face nel Save Menu

[HELP]una stringa mi impalla tutto

Total Conversion VX to XP

Allineamento Neutrale/Buono/Cattivo

Hud Graphic

MINTO Special Transition

Modulo MINTO

Fare in modo che premendo un tasto si attivi l'HUD su mappa

Multiple Frame Title

Minigioco del Puzle

Total Conversion VX to XP

Browse

Activity