[Sportello aiuti veloci VX-Ace]

@Maker appena posso controllo e ti rispondo in PM.

 

Holy grazie ;D hai trovato niente?

[Sportello aiuti veloci VX-Ace]

Grazie Holy ;)

[Sportello aiuti veloci VX-Ace]

Ora te lo posto!

http://www.mediafire.com/?yjt8srw7m69ljvt

Ecco il file script...

[Sportello aiuti veloci VX-Ace]

Si, scusa Holy se ti sto buttando la pressione.Se vuoi ti posso postare il progetto con tutto il file per modificare?

[luce dinamica]

Dai un'occhiata a questo script : Khas Awesome Light Effects

cerca con google

[Sportello aiuti veloci VX-Ace]

E riguardante il mio problema? :P se non lo risolvo non lo posso continuare D:

[Sportello aiuti veloci VX-Ace]

No, il battle log mi funziona e poi non uso il battle engine uso il sideview

Edit: provando su nuovo progetto mi da errore quando aggiungo : ▼ Yanfly Engine Ace - Party System v1.08

nella riga: @effect_sprites.update

[Sportello aiuti veloci VX-Ace]

Ho fatto così dal primo script di material:

-Taglia script

-testa gioco

-Metti sotto Bs

Ho fatto così fino allo script logs battaglia (▼ Yanfly Engine Ace - Combat Log Display v1.02)

Mi dà l'errore nello scene battle:

 

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

# ■ Scene_Battle

#------------------------------------------------------------------------------

# 　バトル画面の処理を行うクラスです。

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

class Scene_Battle < Scene_Base

#--------------------------------------------------------------------------

# ● フレーム更新（基本）

#--------------------------------------------------------------------------

alias update_basic_scene_battle_n03 update_basic

def update_basic

update_basic_scene_battle_n03

$sv_camera.update

$sv_camera.wait = N03::TURN_END_WAIT + 1 if $sv_camera.win_wait

camera_wait

end

#--------------------------------------------------------------------------

# ● カメラウェイト

#--------------------------------------------------------------------------

def camera_wait

process_event if $sv_camera.event

$sv_camera.event = false if $sv_camera.event

while $sv_camera.wait != 0

Graphics.update

Input.update

update_all_windows

$game_timer.update

$game_troop.update

$sv_camera.update

@spriteset.update

update_info_viewport

update_message_open

$sv_camera.wait -= 1 if $sv_camera.wait > 0

$sv_camera.wait = 1 if $sv_camera.wait == 0 && @spriteset.effect?

BattleManager.victory if $sv_camera.win_wait && $sv_camera.wait == 0

end

end

#--------------------------------------------------------------------------

# ● カメラウェイトのセット

#--------------------------------------------------------------------------

def set_camera_wait(time)

$sv_camera.wait = time

camera_wait

end

#--------------------------------------------------------------------------

# ● エフェクト実行が終わるまでウェイト ★再定義

#--------------------------------------------------------------------------

def wait_for_effect

end

#--------------------------------------------------------------------------

# ● ターン開始

#--------------------------------------------------------------------------

alias turn_start_scene_battle_n03 turn_start

def turn_start

turn_start_scene_battle_n03

N03.camera(nil, N03::BATTLE_CAMERA["ターン開始後"].dup)

end

#--------------------------------------------------------------------------

# ● ターン終了

#--------------------------------------------------------------------------

alias turn_end_scene_battle_n03 turn_end

def turn_end

turn_end_scene_battle_n03

for member in $game_troop.members + $game_party.members

N03.set_damage(member, member.sv.result_damage[0],member.sv.result_damage[1])

member.sv.result_damage = [0,0]

@spriteset.set_damage_pop(member) if member.result.hp_damage != 0 or member.result.mp_damage != 0

end

set_camera_wait(N03::TURN_END_WAIT)

N03.camera(nil, N03::BATTLE_CAMERA["ターン開始前"].dup) if $game_party.inputable?

@log_window.clear

end

#--------------------------------------------------------------------------

# ● スキル／アイテムの使用 ★再定義

#--------------------------------------------------------------------------

def use_item

item = @subject.current_action.item

display_item(item)

@subject.use_item(item)

refresh_status

@targets = @subject.current_action.make_targets.compact

@targets = [@subject] if @targets.size == 0

set_substitute(item)

for time in item.repeats.times do play_sideview(@targets, item) end

end_reaction(item)

display_end_item

end

#--------------------------------------------------------------------------

# ● スキル／アイテム名の表示

#--------------------------------------------------------------------------

def display_item(item)

return @log_window.display_use_item(@subject, item) if N03::BATTLE_LOG

@log_window.off

@skill_name_window = Window_Skill_name.new(item.name) unless N03::NO_DISPLAY_SKILL_ID.include?(item.id) && item.is_a?(RPG::Skill)

end

#--------------------------------------------------------------------------

# ● スキル／アイテム名の表示終了

#--------------------------------------------------------------------------

def display_end_item

@skill_name_window.dispose if @skill_name_window != nil

@skill_name_window = nil

set_camera_wait(N03::ACTION_END_WAIT) if @subject.sv.derivation_skill_id == 0

@log_window.clear if N03::BATTLE_LOG

end

#--------------------------------------------------------------------------

# ● 反撃／魔法反射／身代わり処理

#--------------------------------------------------------------------------

def end_reaction(item)

end_substitute if @substitute != nil

set_reflection(item) if @reflection_data != nil

set_counter_attack if @counter_attacker != nil

end

#--------------------------------------------------------------------------

# ● 反撃の発動 ★再定義

#--------------------------------------------------------------------------

def invoke_counter_attack(target, item)

return if @subject.sv.counter_id != 0

@counter_attacker = [] if @counter_attacker == nil

return apply_item_effects(apply_substitute(target, item), item) if !target.movable?

@log_window.add_text(sprintf(Vocab::CounterAttack, target.name)) if N03::BATTLE_LOG

target.sv.counter_id = target.sv.counter_skill_id

@counter_attacker.push(target)

end

#--------------------------------------------------------------------------

# ● 魔法反射の発動 ★再定義

#--------------------------------------------------------------------------

def invoke_magic_reflection(target, item)

return if @subject.sv.reflection_id != 0

@log_window.add_text(sprintf(Vocab::MagicReflection, target.name)) if N03::BATTLE_LOG

target.sv.reflection_id = target.sv.reflection_anime_id

end

#--------------------------------------------------------------------------

# ● 身代わりの適用 ★再定義

#--------------------------------------------------------------------------

def apply_substitute(target, item)

return target if @substitute == nil

return target if !check_substitute(target, item)

return @substitute

end

#--------------------------------------------------------------------------

# ● 身代わりセット

#--------------------------------------------------------------------------

def set_substitute(item)

@substitute = N03.get_enemy_unit(@subject).substitute_battler

return if @substitute == nil

s_targets = []

for i in 0...@targets.size

next if @targets == @substitute

next if !check_substitute(@targets, item)

@log_window.add_text(sprintf(Vocab::Substitute, @substitute.name, @targets.name))

@targets.sv.start_action(@targets.sv.substitute_receiver_start_action)

s_targets.push(@targets)

@targets = @substitute

end

return @substitute = nil if s_targets == []

@substitute.sv.set_target(s_targets)

@substitute.sv.start_action(@substitute.sv.substitute_start_action)

end

#--------------------------------------------------------------------------

# ● 身代わり終了

#--------------------------------------------------------------------------

def end_substitute

for member in @substitute.sv.target_battler

member.sv.start_action(member.sv.substitute_receiver_end_action)

end

@substitute.sv.start_action(@substitute.sv.substitute_end_action)

@substitute = nil

end

#--------------------------------------------------------------------------

# ● 反撃

#--------------------------------------------------------------------------

def set_counter_attack

pre_subject = @subject

for attacker in @counter_attacker

@subject = attacker

item = $data_skills[attacker.sv.counter_skill_id]

play_sideview([pre_subject], item)

end

# 同一カウンター者を考慮してカウンターIDの初期化はアクション後に実行

for attacker in @counter_attacker do attacker.sv.counter_id = 0 end

@subject = pre_subject

@counter_attacker = nil

end

#--------------------------------------------------------------------------

# ● 魔法反射

#--------------------------------------------------------------------------

def set_reflection(item)

@log_window.back_to(1)

for data in @reflection_data

@subject.sv.damage_action(@subject, item)

N03.set_damage_anime_data([@subject], @subject, data)

apply_item_effects(@subject, item)

@spriteset.set_damage_pop(@subject)

end

set_camera_wait(N03.get_anime_time(@reflection_data[0][0]))

@reflection_data = nil

end

#--------------------------------------------------------------------------

# ● サイドビューアクション実行

#--------------------------------------------------------------------------

def play_sideview(targets, item)

@subject.sv.set_target(targets)

return if @subject.sv.attack_action(item) == nil

return if !@subject.movable?

return if item.scope != 9 && item.scope != 10 && !N03.targets_alive?(targets)

@subject.sv.start_action(@subject.sv.attack_action(item))

@subject.sv.unshift_action(@subject.sv.flash_action) if @subject.flash_flg

@subject.sv.active = true

loop do

update_basic

data = @subject.sv.play_data

@targets = N03.s_targets(@subject) if data[0] == "second_targets_set"

N03.targets_set(@subject) if data[0] == "targets_set"

@immortal = N03.immortaling if data[0] == "no_collapse" && !N03.dead_attack?(@subject, item)

@immortal = N03.unimmortaling if data[0] == "collapse"

next set_move_anime(item) if @subject.sv.m_a_data != []

set_damage(item) if @subject.sv.set_damage

break N03.derived_skill(@subject) if @subject.sv.derivation_skill_id != 0

break if @subject.sv.action_end or @subject.hidden?

end

@immortal = N03.unimmortaling if @immortal

end

#--------------------------------------------------------------------------

# ● ダメージの実行

#--------------------------------------------------------------------------

def set_damage(item)

targets = @targets

targets = [@subject.sv.individual_targets[0]] if @subject.sv.individual_targets.size != 0

for target in targets do damage_anime(targets.dup, target, item) end

@subject.sv.set_damage = false

@subject.sv.damage_anime_data = []

end

#--------------------------------------------------------------------------

# ● ダメージ戦闘アニメ処理

#--------------------------------------------------------------------------

def damage_anime(targets, target, item)

@log_window.back_to(1) if @log_window.line_number == 5

return if item.scope != 9 && item.scope != 10 && target.dead?

@miss = false

invoke_item(target,item)

if target.result.missed

target.sv.miss_action(@subject, item)

return @miss = true

elsif target.result.evaded or target.sv.counter_id != 0

target.sv.evasion_action(@subject, item)

return @miss = true

elsif target.sv.reflection_id != 0

N03.set_damage_anime_data(targets, target, [target.sv.reflection_id, false, false, true])

target.sv.reflection_id = 0

@reflection_data = [] if @reflection_data == nil

return @reflection_data.push([N03.get_attack_anime_id(-3, @subject), false, false, true])

end

target.sv.damage_action(@subject, item)

N03.set_damage(@subject, -target.result.hp_drain, -target.result.mp_drain) if target != @subject

@spriteset.set_damage_pop(target)

@spriteset.set_damage_pop(@subject) if target != @subject && @subject.result.hp_damage != 0 or @subject.result.mp_damage != 0

N03.set_damage_anime_data(targets, target, @subject.sv.damage_anime_data) if @subject.sv.damage_anime_data != []

end

#--------------------------------------------------------------------------

# ● 飛ばしアニメ処理

#--------------------------------------------------------------------------

def set_move_anime(item)

for data in @subject.sv.m_a_data

@subject.sv.damage_anime_data = data[4]

hit_targets = []

for target in data[1]

damage_anime(data[1], target, item) if data[0]

hit_targets.push(target) if !@miss

end

@miss = false if !data[3]

@spriteset.set_hit_animation(@subject, data[2], hit_targets, @miss)

end

@subject.sv.set_damage = false

@subject.sv.m_a_data = []

end

end

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

# ■ DataManager

#------------------------------------------------------------------------------

# 　データベースとゲームオブジェクトを管理するモジュールです。

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

module DataManager

#--------------------------------------------------------------------------

# ● 各種ゲームオブジェクトの作成 ★再定義

#--------------------------------------------------------------------------

def self.create_game_objects

$game_temp = Game_Temp.new

$game_system = Game_System.new

$game_timer = Game_Timer.new

$game_message = Game_Message.new

$game_switches = Game_Switches.new

$game_variables = Game_Variables.new

$game_self_switches = Game_SelfSwitches.new

$game_actors = Game_Actors.new

$game_party = Game_Party.new

$game_troop = Game_Troop.new

$game_map = Game_Map.new

$game_player = Game_Player.new

$sv_camera = Battle_Camera.new

end

end

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

# ■ BattleManager

#------------------------------------------------------------------------------

# 　戦闘の進行を管理するモジュールです。

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

module BattleManager

#--------------------------------------------------------------------------

# ● エンカウント時の処理 ★再定義

#--------------------------------------------------------------------------

def self.on_encounter

@preemptive = (rand < rate_preemptive)

@surprise = (rand < rate_surprise && !@preemptive)

$sv_camera.mirror = @surprise if N03::BACK_ATTACK

end

#--------------------------------------------------------------------------

# ● 勝利の処理 ★再定義

#--------------------------------------------------------------------------

def self.process_victory

$sv_camera.win_wait = true

end

#--------------------------------------------------------------------------

# ● 勝利

#--------------------------------------------------------------------------

def self.victory

$sv_camera.win_wait = false

N03.camera(nil, N03::BATTLE_CAMERA["戦闘終了時"].dup)

for member in $game_party.members do member.sv.start_action(member.sv.win) if member.movable? end

play_battle_end_me

replay_bgm_and_bgs

$game_message.add(sprintf(Vocab::Victory, $game_party.name))

display_exp

gain_gold

gain_drop_items

gain_exp

SceneManager.return

battle_end(0)

return true

end

#--------------------------------------------------------------------------

# ● 逃走の処理 ★再定義

#--------------------------------------------------------------------------

def self.process_escape

$game_message.add(sprintf(Vocab::EscapeStart, $game_party.name))

success = @preemptive ? true : (rand < @escape_ratio)

Sound.play_escape

if success

process_abort

for member in $game_party.members do member.sv.start_action(member.sv.escape) if member.movable? end

else

@escape_ratio += 0.1

$game_message.add('\.' + Vocab::EscapeFailure)

$game_party.clear_actions

for member in $game_party.members do member.sv.start_action(member.sv.escape_ng) if member.movable? end

end

wait_for_message

return success

end

#--------------------------------------------------------------------------

# ● 次のコマンド入力へ ★再定義

#--------------------------------------------------------------------------

def self.next_command

begin

if !actor || !actor.next_command

@actor_index += 1

if @actor_index >= $game_party.members.size

for member in $game_party.battle_members.reverse

break member.sv.start_action(member.sv.command_a) if member.inputable?

end

return false

end

end

end until actor.inputable?

actor.sv.start_action(actor.sv.command_b) if actor != nil && actor.inputable?

if pre_actor

pre_actor.sv.start_action(pre_actor.sv.command_a) if pre_actor != nil && pre_actor.inputable?

end

return true

end

#--------------------------------------------------------------------------

# ● 前のコマンド入力へ ★再定義

#--------------------------------------------------------------------------

def self.prior_command

begin

if !actor || !actor.prior_command

@actor_index -= 1

if @actor_index < 0

for member in $game_party.battle_members

break member.sv.start_action(member.sv.command_a) if member.inputable?

end

return false

end

end

end until actor.inputable?

actor.make_actions if actor.inputable?

actor.sv.start_action(actor.sv.command_b) if actor.inputable?

after_actor.sv.start_action(after_actor.sv.command_a) if after_actor != nil && after_actor.inputable?

return true

end

#--------------------------------------------------------------------------

# ● コマンド入力前のアクターを取得

#--------------------------------------------------------------------------

def self.pre_actor

return if @actor_index == 0

$game_party.members[@actor_index - 1]

end

#--------------------------------------------------------------------------

# ● コマンド入力後のアクターを取得

#--------------------------------------------------------------------------

def self.after_actor

$game_party.members[@actor_index + 1]

end

#--------------------------------------------------------------------------

# ● 戦闘行動者を前に追加

#--------------------------------------------------------------------------

def self.unshift_action_battlers(battler)

@action_battlers.unshift(battler)

end

end

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

# ■ Game_Battler

#------------------------------------------------------------------------------

# 　スプライトや行動に関するメソッドを追加したバトラーのクラスです。

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

class Game_Battler < Game_BattlerBase

#--------------------------------------------------------------------------

# ● 公開インスタンス変数

#--------------------------------------------------------------------------

attr_reader :sv # サイドビューデータ

attr_accessor :flash_flg # 閃きフラグ

#--------------------------------------------------------------------------

# ● オブジェクト初期化

#--------------------------------------------------------------------------

alias initialize_game_battler_n03 initialize

def initialize

initialize_game_battler_n03

@sv = SideView.new(self)

end

#--------------------------------------------------------------------------

# ● 現在の戦闘行動を除去

#--------------------------------------------------------------------------

alias remove_current_action_game_battler_n03 remove_current_action

def remove_current_action

return @sv.derivation_skill_id = 0 if @sv.derivation_skill_id != 0

remove_current_action_game_battler_n03

end

#--------------------------------------------------------------------------

# ● ターン終了処理

#--------------------------------------------------------------------------

alias on_turn_end_game_battler_n03 on_turn_end

def on_turn_end

on_turn_end_game_battler_n03

@sv.add_state = []

@sv.result_damage = [@result.hp_damage, @result.mp_damage]

end

#--------------------------------------------------------------------------

# ● パラメータ条件比較 data = [種別, 数値, 判別]

#--------------------------------------------------------------------------

def comparison_parameter(data)

return true if data[0][0] == 0

kind = data[0]

num = data[1]

select = data[2]

case kind

when 1 ; par = level

when 2 ; par = mhp

when 3 ; par = mmp

when 4 ; par = hp

when 5 ; par = mp

when 6 ; par = tp

when 7 ; par = atk

when 8 ; par = self.def

when 9 ; par = mat

when 10 ; par = mdf

when 11 ; par = agi

when 12 ; par = luk

end

if num < 0

case kind

when 4 ; num = mhp * num / 100

when 5 ; num = mmp * num / 100

when 6 ; num = max_tp * num / 100

end

num = num.abs

end

case select

when 0 ; return par == num

when 1 ; return par < num

when 2 ; return par > num

end

end

#--------------------------------------------------------------------------

# ● 装備条件比較 data = [装備種別, タイプID]

#--------------------------------------------------------------------------

def comparison_equip(data)

kind = data[0]

items = weapons if kind == 0

items = armors if kind == 1

for item in items

for id in data[1]

return true if id > 0 && item.is_a?(RPG::Weapon) && item == $data_weapons[id.abs]

return true if id > 0 && item.is_a?(RPG::Armor) && item == $data_armors[id.abs]

return true if id < 0 && item.is_a?(RPG::Weapon) && item.wtype_id == id.abs

return true if id < 0 && item.is_a?(RPG::Armor) && item.stype_id == id.abs

end

end

return false

end

 

end

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

# ■ Game_Actor

#------------------------------------------------------------------------------

# 　アクターを扱うクラスです。

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

class Game_Actor < Game_Battler

#--------------------------------------------------------------------------

# ● 公開インスタンス変数

#--------------------------------------------------------------------------

attr_reader :actor_id # ID

#--------------------------------------------------------------------------

# ● ID

#--------------------------------------------------------------------------

def id

return @actor_id

end

#--------------------------------------------------------------------------

# ● スプライトを使うか？ ★再定義

#--------------------------------------------------------------------------

def use_sprite?

return true

end

#--------------------------------------------------------------------------

# ● ダメージ効果の実行 ★再定義

#--------------------------------------------------------------------------

def perform_damage_effect

return if !N03::ACTOR_DAMAGE

$game_troop.screen.start_shake(5, 5, 10)

@sprite_effect_type = :blink

Sound.play_actor_damage

end

 

end

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

# ■ Game_Enemy

#------------------------------------------------------------------------------

# 　敵キャラを扱うクラスです。

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

class Game_Enemy < Game_Battler

#--------------------------------------------------------------------------

# ● 公開インスタンス変数

#--------------------------------------------------------------------------

attr_reader :enemy_id # ID

#--------------------------------------------------------------------------

# ● ID

#--------------------------------------------------------------------------

def id

return @enemy_id

end

#--------------------------------------------------------------------------

# ● レベル

#--------------------------------------------------------------------------

def level

return @sv.level

end

#--------------------------------------------------------------------------

# ● ダメージ効果の実行 ★再定義

#--------------------------------------------------------------------------

def perform_damage_effect

return if !N03::ENEMY_DAMAGE

@sprite_effect_type = :blink

Sound.play_enemy_damage

end

#--------------------------------------------------------------------------

# ● 武器

#--------------------------------------------------------------------------

def weapons

weapon1 = $data_weapons[@sv.enemy_weapon1_id]

weapon2 = $data_weapons[@sv.enemy_weapon2_id]

return [weapon1, weapon2]

end

#--------------------------------------------------------------------------

# ● 防具

#--------------------------------------------------------------------------

def armors

return [$data_armors[@sv.enemy_shield_id]]

end

#--------------------------------------------------------------------------

# ● 二刀流の判定

#--------------------------------------------------------------------------

def dual_wield?

return $data_weapons[@sv.enemy_weapon2_id] != nil

end

#--------------------------------------------------------------------------

# ● バトラー画像変更

#--------------------------------------------------------------------------

def graphics_change(battler_name)

@battler_name = battler_name

end

#--------------------------------------------------------------------------

# ● 通常攻撃 アニメーション ID の取得

#--------------------------------------------------------------------------

def atk_animation_id1

return weapons[0].animation_id if weapons[0]

return weapons[1] ? 0 : 1

end

#--------------------------------------------------------------------------

# ● 通常攻撃 アニメーション ID の取得（二刀流：武器２）

#--------------------------------------------------------------------------

def atk_animation_id2

return weapons[1] ? weapons[1].animation_id : 0

end

end

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

# ■ Sprite_Base

#------------------------------------------------------------------------------

# 　アニメーションの表示処理を追加したスプライトのクラスです。

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

class Sprite_Base < Sprite

#--------------------------------------------------------------------------

# ● アニメーションの座標更新 (ホーミングあり)

#--------------------------------------------------------------------------

def update_animation_position_horming

return if @action_end_cancel

ani_ox_set if @horming

camera_zoom = $sv_camera.zoom

camera_zoom = 1 if @move_anime

kind = 1

kind = -1 if @ani_mirror && !@anime_no_mirror

cell_data = @animation.frames[@animation.frame_max - (@ani_duration + @ani_rate - 1) / @ani_rate].cell_data

for i in 0..15

@ani_sprites.x = (@ani_ox + cell_data[i, 1] * kind - $sv_camera.x) * camera_zoom if @ani_sprites != nil && cell_data[i, 1] != nil

@ani_sprites.y = (@ani_oy + cell_data[i, 2] - $sv_camera.y) * camera_zoom if @ani_sprites != nil && cell_data[i, 2] != nil

end

end

#--------------------------------------------------------------------------

# ● アニメーション元の座標をセット

#--------------------------------------------------------------------------

def ani_ox_set

@real_x = x if !@real_x

@real_y = y if !@real_y

@ani_ox = @real_x - ox + width / 2

@ani_oy = @real_y - oy + height / 2

@ani_oy -= height / 2 if @animation.position == 0

@ani_oy += height / 2 if @animation.position == 2

end

#--------------------------------------------------------------------------

# ● アニメーションの更新

#--------------------------------------------------------------------------

alias update_animation_sprite_base_n03 update_animation

def update_animation

update_animation_position_horming if animation? && SceneManager.scene_is?(Scene_Battle) && @animation.position != 3

update_animation_sprite_base_n03

end

#--------------------------------------------------------------------------

# ● アニメーションの原点設定 ★再定義

#--------------------------------------------------------------------------

def set_animation_origin

return ani_ox_set if @animation.position != 3

if viewport == nil

@ani_ox = Graphics.width / 2

@ani_oy = Graphics.height / 2

else

@ani_ox = viewport.rect.width / 2

@ani_oy = viewport.rect.height / 2

end

end

#--------------------------------------------------------------------------

# ● アニメーションスプライトの設定 ★再定義

#--------------------------------------------------------------------------

def animation_set_sprites(frame)

camera_zoom = 1

camera_zoom = $sv_camera.zoom if @anime_camera_zoom && @animation.position != 3 && SceneManager.scene_is?(Scene_Battle)

camera_x = $sv_camera.x

camera_y = $sv_camera.y

camera_x = camera_y = 0 if @animation.position == 3 or !SceneManager.scene_is?(Scene_Battle)

plus_z = 5

plus_z = 1000 if @animation.position == 3

plus_z = -17 if @plus_z != nil && @plus_z == false

plus_z = -self.z + 10 if @plus_z != nil && @plus_z == false && @animation.position == 3

cell_data = frame.cell_data

@ani_sprites.each_with_index do |sprite, i|

next unless sprite

pattern = cell_data[i, 0]

if !pattern || pattern < 0

sprite.visible = false

next

end

sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2

sprite.visible = true

sprite.src_rect.set(pattern % 5 * 192,

pattern % 100 / 5 * 192, 192, 192)

if @ani_mirror && !@anime_no_mirror

sprite.x = (@ani_ox - cell_data[i, 1] - camera_x) * camera_zoom

sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom

sprite.angle = (360 - cell_data[i, 4])

sprite.mirror = (cell_data[i, 5] == 0)

else

sprite.x = (@ani_ox + cell_data[i, 1] - camera_x) * camera_zoom

sprite.y = (@ani_oy + cell_data[i, 2] - camera_y) * camera_zoom

sprite.angle = cell_data[i, 4]

sprite.mirror = (cell_data[i, 5] == 1)

end

sprite.z = self.z + plus_z + i

sprite.ox = 96

sprite.oy = 96

sprite.zoom_x = cell_data[i, 3] * camera_zoom / 100.0

sprite.zoom_y = cell_data[i, 3] * camera_zoom/ 100.0

sprite.opacity = cell_data[i, 6] * self.opacity / 255.0

sprite.blend_type = cell_data[i, 7]

end

end

#--------------------------------------------------------------------------

# ● 子スプライトフラグ

#--------------------------------------------------------------------------

def set(battler, horming, camera_zoom, no_mirror)

@battler = battler

@next = true

self.bitmap = Bitmap.new(@battler.sv.cw, @battler.sv.ch)

self.ox = bitmap.width / 2

self.oy = bitmap.height

@horming = horming

@anime_camera_zoom = camera_zoom

@anime_no_mirror = no_mirror

@battler.sv.reset_anime_data

end

#--------------------------------------------------------------------------

# ● 子スプライト座標セット

#--------------------------------------------------------------------------

def set_position(z, zoom_x, zoom_y, real_x, real_y)

self.z = z

self.zoom_x = zoom_x

self.zoom_y = zoom_y

@real_x = real_x

@real_y = real_y

end

#--------------------------------------------------------------------------

# ● 他スプライトへのタイミング処理

#--------------------------------------------------------------------------

def other_process_timing(timing)

se_flag = true

se_flag = @se_flag if @se_flag != nil

@battler.sv.timing.push([se_flag, timing.dup])

end

#--------------------------------------------------------------------------

# ● 他バトラーへのタイミング処理

#--------------------------------------------------------------------------

def target_battler_process_timing(timing)

for target in @timing_targets

target.sv.timing.push([false, timing.dup])

end

end

#--------------------------------------------------------------------------

# ● SE とフラッシュのタイミング処理

#--------------------------------------------------------------------------

alias animation_process_timing_sprite_base_n03 animation_process_timing

def animation_process_timing(timing)

#target_battler_process_timing(timing) if @timing_targets && @timing_targets != []

return other_process_timing(timing) if @next != nil

animation_process_timing_sprite_base_n03(timing)

end

end

 

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

# ■ Sprite_Battler

#------------------------------------------------------------------------------

# 　バトラー表示用のスプライトです。

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

class Sprite_Battler < Sprite_Base

#--------------------------------------------------------------------------

# ● 公開インスタンス変数　

#--------------------------------------------------------------------------

attr_accessor :removing # パーティ離脱中

#--------------------------------------------------------------------------

# ● オブジェクト初期化

#--------------------------------------------------------------------------

alias initialize_sprite_battler_n03 initialize

def initialize(viewport, battler = nil)

initialize_sprite_battler_n03(viewport, battler)

@real_x = @real_y = 0

update_bitmap if @battler != nil

end

#--------------------------------------------------------------------------

# ● アニメーションの開始 ★再定義

#--------------------------------------------------------------------------

def start_animation(animation, mirror = false)

return next_animation(animation, mirror) if animation?

@animation = animation

if @animation

@horming = @battler.sv.anime_horming

@anime_camera_zoom = @battler.sv.anime_camera_zoom

@anime_no_mirror = @battler.sv.anime_no_mirror

@timing_targets = @battler.sv.timing_targets

@plus_z = @battler.sv.anime_plus_z

@battler.sv.reset_anime_data

@ani_mirror = mirror

set_animation_rate

@ani_duration = @animation.frame_max * @ani_rate + 1

load_animation_bitmap

make_animation_sprites

set_animation_origin

end

end

#--------------------------------------------------------------------------

# ● 次のアニメを開始

#--------------------------------------------------------------------------

def next_animation(animation, mirror)

@next_anime = [] if @next_anime == nil

@next_anime.push(Sprite_Base.new(viewport))

@next_anime[@next_anime.size - 1].set(battler, @battler.sv.anime_horming, @battler.sv.anime_camera_zoom, @battler.sv.anime_no_mirror)

@next_anime[@next_anime.size - 1].set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y)

@next_anime[@next_anime.size - 1].start_animation(animation, mirror)

end

#--------------------------------------------------------------------------

# ● 影グラフィック作成

#--------------------------------------------------------------------------

def create_shadow

reset_shadow

return if @battler.sv.shadow == false

@shadow = Sprite.new(viewport) if @shadow == nil

@shadow.bitmap = Cache.character(@battler.sv.shadow)

@shadow.ox = @shadow.bitmap.width / 2

@shadow.oy = @shadow.bitmap.height / 2

end

#--------------------------------------------------------------------------

# ● 影グラフィック初期化

#--------------------------------------------------------------------------

def reset_shadow

return if @shadow == nil

@shadow.dispose

@shadow = nil

end

#--------------------------------------------------------------------------

# ● 転送元ビットマップの更新 ★再定義

#--------------------------------------------------------------------------

def update_bitmap

update_bitmap_enemy if !@battler.actor?

update_bitmap_actor if @battler.actor?

update_src_rect if @battler != nil

update_color if @battler != nil

end

#--------------------------------------------------------------------------

# ● 転送元ビットマップ:エネミー

#--------------------------------------------------------------------------

def update_bitmap_enemy

if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue

@battler_name = @battler.battler_name

@battler_hue = @battler.battler_hue

@battler_graphic_file_index = @battler.sv.graphic_file_index

@graphic_mirror_flag = @battler.sv.graphic_mirror_flag

self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue)

@battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)

create_shadow

init_visibility

@battler_id = @battler.id

end

end

#--------------------------------------------------------------------------

# ● 転送元ビットマップ:アクター

#--------------------------------------------------------------------------

def update_bitmap_actor

if @battler.character_name != @battler_name or @battler.character_index != @battler_index

@battler_name = @battler.character_name

@battler_index = @battler.character_index

@battler_graphic_file_index = @battler.sv.graphic_file_index

@graphic_mirror_flag = @battler.sv.graphic_mirror_flag

self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index)

@battler.sv.setup(self.bitmap.width, self.bitmap.height, @battler_id != @battler.id)

create_shadow

init_visibility

@battler_id = @battler.id

end

end

#--------------------------------------------------------------------------

# ● 可視状態の初期化 ★再定義

#--------------------------------------------------------------------------

def init_visibility

@battler_visible = @battler.alive?

@battler_visible = true if @battler.sv.state(1) != "敵コラプス"

@battler_visible = false if @battler.hidden?

@battler.sv.opacity = 0 unless @battler_visible

self.opacity = 0 unless @battler_visible

self.opacity = 255 if @battler_visible

@battler.sv.weapon_visible = @battler_visible

end

#--------------------------------------------------------------------------

# ● 転送元矩形の更新

#--------------------------------------------------------------------------

def update_src_rect

return if @battler.sv.collapse

if @battler_graphic_file_index != @battler.sv.graphic_file_index

@battler_graphic_file_index = @battler.sv.graphic_file_index

self.bitmap = Cache.character(@battler_name + @battler_graphic_file_index) if @battler.actor?

self.bitmap = Cache.battler(@battler_name + @battler_graphic_file_index, @battler_hue) if !@battler.actor?

@battler.sv.set_graphics(self.bitmap.width, self.bitmap.height)

end

self.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)

self.opacity = @battler.sv.opacity if @battler_visible

set_process_timing(@battler.sv.timing) if @battler && @battler.sv.timing != []

end

#--------------------------------------------------------------------------

# ● 位置の更新 ★再定義

#--------------------------------------------------------------------------

def update_position

@real_x = @battler.sv.x / 100

@real_y = (@battler.sv.y - @battler.sv.h - @battler.sv.j - @battler.sv.c - @battler.sv.oy_adjust)/ 100

self.x = @real_x - $sv_camera.x

self.y = @real_y - $sv_camera.y

self.z = @battler.sv.z - @battler.sv.c / 100

if @battler.sv.h <= 0

self.x += $sv_camera.sx / 100

self.y += $sv_camera.sy / 100

end

self.x *= $sv_camera.zoom

self.y *= $sv_camera.zoom

end

#--------------------------------------------------------------------------

# ● 原点の更新 ★再定義

#--------------------------------------------------------------------------

def update_origin

return if !bitmap or @battler.sv.collapse

self.ox = @battler.sv.ox

self.oy = @battler.sv.oy

self.angle = @battler.sv.angle

self.zoom_x = @battler.sv.zoom_x * $sv_camera.zoom

self.zoom_y = @battler.sv.zoom_y * $sv_camera.zoom

self.mirror = @battler.sv.mirror if !@graphic_mirror_flag

self.mirror = !@battler.sv.mirror if @graphic_mirror_flag

end

#--------------------------------------------------------------------------

# ● 影グラフィックの更新

#--------------------------------------------------------------------------

def update_shadow

@shadow.visible = @battler.sv.shadow_visible

@shadow.opacity = @battler.sv.opacity if @battler.sv.opacity_data[3]

@shadow.opacity = self.opacity if !@battler.sv.opacity_data[3]

@shadow.x = @real_x - $sv_camera.x

@shadow.y = (@battler.sv.y - @battler.sv.c)/ 100 - $sv_camera.y

@shadow.z = @battler.sv.z - 10

@shadow.zoom_x = $sv_camera.zoom

@shadow.zoom_y = $sv_camera.zoom

@shadow.x += $sv_camera.sx / 100

@shadow.y += $sv_camera.sy / 100

@shadow.x *= $sv_camera.zoom

@shadow.y *= $sv_camera.zoom

@shadow.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil

end

#--------------------------------------------------------------------------

# ● ふきだしの更新

#--------------------------------------------------------------------------

def update_balloon

if @battler.sv.balloon_data == [] && @balloon

@balloon_data = []

@balloon.dispose

return @balloon = nil

elsif @battler.sv.balloon_data != [] && @battler.sv.balloon_data != @balloon_data

@balloon_data = @battler.sv.balloon_data

@balloon = Sprite.new(self.viewport)

@balloon.bitmap = Cache.system("Balloon")

@balloon.zoom_x = @balloon_data[3]

@balloon.zoom_y = @balloon_data[3]

@balloon.ox = 32 if @battler.sv.mirror

@balloon.oy = 16

@balloon_count = 0

end

return if !@balloon

@balloon.opacity = self.opacity

@balloon.x = self.x

@balloon.y = self.y - @battler.sv.ch * $sv_camera.zoom

@balloon.z = self.z + 20

@balloon.src_rect.set(32 + @balloon_count / @balloon_data[2] * 32, @balloon_data[1] * 32, 32, 32) if @balloon_count % @balloon_data[2] == 0

@balloon.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil

@balloon_count += 1

@balloon_count = 0 if @balloon_count == @balloon_data[2] * 7

end

#--------------------------------------------------------------------------

# ● 色調変更の更新

#--------------------------------------------------------------------------

def update_color

color_set if @battler.sv.color_set != []

return if @color_data == nil

@color_data[4] -= 1

if @color_data[4] == 0 && @color_data[5] != 0

@color_data[4] = @color_data[5]

@color_data[5] = 0

@color_data[6] = [0,0,0,0]

elsif @color_data[4] == 0

@remain_color_data = @color_data

@battler.sv.color = @color_data.dup

return @color_data = nil

end

for i in 0..3

@color_data = (@color_data * (@color_data[4] - 1) + @color_data[6]) / @color_data[4]

end

@battler.sv.color = @color_data.dup

self.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3])

end

#--------------------------------------------------------------------------

# ● 残像の更新

#--------------------------------------------------------------------------

def update_mirage

if @battler.sv.mirage == [] && @mirages

@mirage_data = []

for mirage in @mirages do mirage.dispose end

return @mirages = nil

elsif @battler.sv.mirage != [] && @battler.sv.mirage != @mirage_data

@mirage_data = @battler.sv.mirage

@mirages = []

for i in 0...@mirage_data[1] do @mirages = Sprite.new(self.viewport) end

@mirage_count = 0

end

return if !@mirages

@mirage_count += 1

@mirage_count = 0 if @mirage_count == @mirage_data[2] * @mirages.size

for i in 0...@mirages.size

mirage_body(@mirages, @mirage_data[4]) if @mirage_count == 1 + i * @mirage_data[2]

end

end

#--------------------------------------------------------------------------

# ● 残像本体

#--------------------------------------------------------------------------

def mirage_body(body, opacity)

body.bitmap = self.bitmap.dup

body.x = self.x

body.y = self.y

body.ox = self.ox

body.oy = self.oy

body.z = self.z - 20

body.mirror = self.mirror

body.angle = self.angle

body.opacity = opacity * self.opacity / 255

body.zoom_x = self.zoom_x

body.zoom_y = self.zoom_y

body.src_rect.set(@battler.sv.sx, @battler.sv.sy, @battler.sv.cw, @battler.sv.ch)

body.color.set(@color_data[0], @color_data[1], @color_data[2], @color_data[3]) if @color_data != nil

end

#--------------------------------------------------------------------------

# ● 次のアニメを更新

#--------------------------------------------------------------------------

def update_next_anime

return if !@next_anime

for anime in @next_anime

anime.update

anime.set_position(self.z, self.zoom_x, self.zoom_y, @real_x, @real_y) if @horming

anime.dispose if !anime.animation?

@next_anime.delete(anime) if !anime.animation?

end

end

#--------------------------------------------------------------------------

# ● フレーム更新

#--------------------------------------------------------------------------

alias update_sprite_battler_n03 update

def update

@battler.sv.update if @battler

update_sprite_battler_n03

update_next_anime

update_shadow if @battler && @shadow

update_mirage if @battler

update_balloon if @battler

update_remove if @battler && @removing && @battler.sv.change_up

end

#--------------------------------------------------------------------------

# ● バトラー入れ替え

#--------------------------------------------------------------------------

def remove

@battler.sv.start_action(@battler.sv.remove_action)

$sv_camera.wait = 40

@battler.sv.add_action("eval('set_change')")

@removing = true

end

#--------------------------------------------------------------------------

# ● バトラー入れ替えの更新

#--------------------------------------------------------------------------

def update_remove

@battler.sv.change_up = false

@removing = false

@battler = nil

end

#--------------------------------------------------------------------------

# ● バトラー加入

#--------------------------------------------------------------------------

def join(join_battler)

$sv_camera.wait = 30

@battler = join_battler

@battler_name = @battler.character_name

@battler_index = @battler.character_index

@battler_graphic_file_index = @battler.sv.graphic_file_index

self.bitmap = Cache.character(@battler_name)

@battler.sv.setup(self.bitmap.width, self.bitmap.height, true)

create_shadow

init_visibility

end

#--------------------------------------------------------------------------

# ● 通常の設定に戻す ★再定義

#--------------------------------------------------------------------------

def revert_to_normal

self.blend_type = 0

self.opacity = 255

end

#--------------------------------------------------------------------------

# ● 崩壊エフェクトの更新

#--------------------------------------------------------------------------

alias update_collapse_sprite_battler_n03 update_collapse

def update_collapse

return if @battler.sv.state(1) != "敵コラプス"

update_collapse_sprite_battler_n03

end

#--------------------------------------------------------------------------

# ● 別スプライトからのタイミング処理

#--------------------------------------------------------------------------

def set_process_timing(timing_data)

for data in timing_data

set_timing(data[0],data[1])

end

@battler.sv.timing = []

end

#--------------------------------------------------------------------------

# ● タイミング処理

#--------------------------------------------------------------------------

def set_timing(se_flag, data)

@ani_rate = 4

data.se.play if se_flag

case data.flash_scope

when 1 ;self.flash(data.flash_color, data.flash_duration * @ani_rate)

when 2 ;viewport.flash(data.flash_color, data.flash_duration * @ani_rate) if viewport

when 3 ;self.flash(nil, data.flash_duration * @ani_rate)

end

end

#--------------------------------------------------------------------------

# ● 色調変更

#--------------------------------------------------------------------------

def color_set

set = @battler.sv.color_set

@battler.sv.color_set= []

set[4] = 1 if set[4] == 0

@remain_color_data = [0,0,0,0] if @remain_color_data == nil

@color_data = @remain_color_data

@color_data[4] = set[4]

@color_data[5] = set[5]

@color_data[6] = set

end

#--------------------------------------------------------------------------

# ● 解放

#--------------------------------------------------------------------------

alias dispose_sprite_battler_n03 dispose

def dispose

dispose_sprite_battler_n03

@shadow.dispose if @shadow != nil

@balloon.dispose if @balloon != nil

for mirage in @mirages do mirage.dispose end if @mirages != nil

end

end

 

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

# ■ Spriteset_Battle

#------------------------------------------------------------------------------

# 　バトル画面のスプライトをまとめたクラスです。

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

class Spriteset_Battle

#--------------------------------------------------------------------------

# ● 戦闘背景（床）スプライトの作成 ★再定義

#--------------------------------------------------------------------------

def create_battleback1

@back1_sprite = Sprite_Battle_Back.new(@viewport1, 1, battleback1_name)

@back1_sprite.set_graphics(battleback1_bitmap) if battleback1_name != nil

@back1_sprite.z = 0

end

#--------------------------------------------------------------------------

# ● 戦闘背景（壁）スプライトの作成 ★再定義

#--------------------------------------------------------------------------

def create_battleback2

@back2_sprite = Sprite_Battle_Back.new(@viewport1, 2, battleback2_name)

@back2_sprite.set_graphics(battleback2_bitmap) if battleback2_name != nil

@back2_sprite.z = 1

end

#--------------------------------------------------------------------------

# ● アクタースプライトの作成 ★再定義

#--------------------------------------------------------------------------

def create_actors

@actor_sprites = []

for i in 0...$game_party.max_battle_members

@actor_sprites = Sprite_Battler.new(@viewport1, $game_party.members)

end

@effect_sprites = Spriteset_Sideview.new(@viewport1)

end

#--------------------------------------------------------------------------

# ● アクタースプライトの更新 ★再定義

#--------------------------------------------------------------------------

def update_actors

@actor_sprites.each_with_index do |sprite, i|

sprite_join($game_party.members, sprite) if sprite.battler == nil && sprite.battler != $game_party.members

sprite.remove if sprite.battler != nil && !sprite.removing && sprite.battler != $game_party.members

sprite.update

end

@effect_sprites.update

update_program

end

#--------------------------------------------------------------------------

# ● メンバーを加える

#--------------------------------------------------------------------------

def sprite_join(member, sprite)

for sp in @actor_sprites

sp.update_remove if member == sp.battler && !sp.battler.sv.change_up

end

sprite.join(member)

end

#--------------------------------------------------------------------------

# ● バトルプログラムの更新

#--------------------------------------------------------------------------

def update_program

return if $sv_camera.program_scroll == []

for data in $sv_camera.program_scroll

@back1_sprite.start_back_data(data) if data[2] == 1

@back2_sprite.start_back_data(data) if data[2] == 2

end

$sv_camera.program_scroll = []

end

#--------------------------------------------------------------------------

# ● ヒット時の戦闘アニメ実行

#--------------------------------------------------------------------------

def set_hit_animation(battler, weapon_index, hit_targets, miss)

@effect_sprites.set_hit_animation(battler, weapon_index, hit_targets, miss)

end

#--------------------------------------------------------------------------

# ● ダメージPOP

#--------------------------------------------------------------------------

def set_damage_pop(target)

@effect_sprites.set_damage_pop(target)

end

#--------------------------------------------------------------------------

# ● 解放

#--------------------------------------------------------------------------

alias dispose_spriteset_battle_n03 dispose

def dispose

dispose_spriteset_battle_n03

@effect_sprites.dispose

end

 

 

 

end

 

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

# ■ Window_BattleLog

#------------------------------------------------------------------------------

# 　戦闘の進行を実況表示するウィンドウです。

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

class Window_BattleLog < Window_Selectable

#--------------------------------------------------------------------------

# ● ウェイト ★再定義

#--------------------------------------------------------------------------

def wait

end

#--------------------------------------------------------------------------

# ● ウェイトとクリア ★再定義

#--------------------------------------------------------------------------

def wait_and_clear

$sv_camera.wait = 10

end

#--------------------------------------------------------------------------

# ● 行動結果の表示 ★再定義

#--------------------------------------------------------------------------

def display_action_results(target, item)

if target.result.used

last_line_number = line_number

display_critical(target, item)

display_damage(target, item)

display_affected_status(target, item)

display_failure(target, item)

end

off if !N03::BATTLE_LOG

end

#--------------------------------------------------------------------------

# ● ウインドウ非表示

#--------------------------------------------------------------------------

def off

@back_sprite.visible = self.visible = false

end

end

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

# ■ Game_Interpreter

#------------------------------------------------------------------------------

# 　イベントコマンドを実行するインタプリタです。

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

class Game_Interpreter

#--------------------------------------------------------------------------

# ● スイッチの操作

#--------------------------------------------------------------------------

alias command_121_game_interpreter_n03 command_121

def command_121

command_121_game_interpreter_n03

$sv_camera.program_check

end

end

.

 

Mi esce il seguente errore: script: (9 quadrati) line 1202 ( @effect_sprites.update) No method error occurred

undefined method 'uptade' for nil:Nilclass

[Sportello aiuti veloci VX-Ace]

Su un nuovo progetto funziona ma come faccio a sapere se va in contrasto con altri script?

Cmq non credo lì parla di zoom!

[Sportello aiuti veloci VX-Ace]

Scusate se interrompo qusta discussione ma è un problema con botta e risposta :L

D: nello scrpt side view precisamente (battle_camera)

#==============================================================================
# ■ Battle_Camera
#------------------------------------------------------------------------------
# 　戦闘カメラやバトルプログラムを扱うクラスです。
#==============================================================================
class Battle_Camera
 #--------------------------------------------------------------------------
 # ● 公開インスタンス変数　
 #--------------------------------------------------------------------------
 attr_reader   :sx				 # シェイクX座標
 attr_reader   :sy				 # シェイクY座標
 attr_reader   :max_top		    # 上限界座標
 attr_reader   :max_bottom		 # 下限界座標
 attr_reader   :max_left		   # 左限界座標
 attr_reader   :max_right		  # 右限界座標
 attr_accessor :switches		   # サイドビュー専用スイッチ
 attr_accessor :color_set		  # 色調変更データ
 attr_accessor :wait			   # 戦闘シーンの強制ウエイト
 attr_accessor :win_wait		   # 戦闘勝利前のウエイト
 attr_accessor :mirror			 # 画面反転フラグ
 attr_accessor :program_scroll	 # バトルプログラム 背景の自動スクロール
 attr_accessor :program_picture    # バトルプログラム 周期ピクチャ
 attr_accessor :event			  # コモンイベント呼び出し
 #--------------------------------------------------------------------------
 # ● オブジェクト初期化
 #--------------------------------------------------------------------------
 def initialize
   @switches = []
   @max_data = []
   @color_set = []
   @wait = 0
   @win_wait = false
   @mirror = false
   @event = false
   setup
 end
 #--------------------------------------------------------------------------
 # ● カメラX座標
 #--------------------------------------------------------------------------
 def x
   return @x / 100
 end
 #--------------------------------------------------------------------------
 # ● カメラY座標
 #--------------------------------------------------------------------------
 def y
   return @y / 100
 end
 #--------------------------------------------------------------------------
 # ● ズーム率
 #--------------------------------------------------------------------------
 def zoom
   return @zoom * 0.001
 end
 #--------------------------------------------------------------------------
 # ● ズーム率による座標変換
 #--------------------------------------------------------------------------
 def convert
   return @zoom
 end
 #--------------------------------------------------------------------------
 # ● カメラセットアップ
 #--------------------------------------------------------------------------
 def setup
   @x = 0
   @y = 0
   @sx = 0
   @sy = 0
   @zoom = 1000
   @time = 0
   @shake_time = 0
   program_setup
 end
 #--------------------------------------------------------------------------
 # ● カメラ初期化
 #--------------------------------------------------------------------------
 def reset
   @switches = []
   @max_data = []
   @color_set = []
   @wait = 0
   @win_wait = false
   @mirror = false
   program_setup(false)
 end 
 #--------------------------------------------------------------------------
 # ● バトルプログラムのセットアップ
 #--------------------------------------------------------------------------
 def program_setup(check = true)
   @played_program  = []
   @program_switch  = []
   @program_sound   = []
   @program_scroll  = []
   @program_se	  = []
   @program_shake   = []
   @program_color   = []
   @program_picture = []
   @program_base = N03::BATTLE_PROGRAM.values.dup
   program_check if check
 end 
 #--------------------------------------------------------------------------
 # ● バトルプログラムのチェック
 #--------------------------------------------------------------------------
 def program_check
   for data in @program_base
  if program_start?(data) && !@played_program.include?(data)
    @played_program.push(data.dup)
    @program_scroll.push(data.dup)  if data[0] == "scroll"
    @program_picture.push(data.dup) if data[0] == "kpic"
    start_sound(data.dup)		   if data[0] == "sound"
    start_program_switch(data.dup)  if data[0] == "switch"
    start_program_se(data.dup)	  if data[0] == "keep_se"
    start_program_shake(data.dup)   if data[0] == "keep_sk"
    start_program_color(data.dup)   if data[0] == "keep_c"
  else
    @played_program.delete(data)  if !program_start?(data)
    @program_scroll.delete(data)  if data[0] == "scroll"
    @program_picture.delete(data) if data[0] == "kpic"
    @program_switch.delete(data)  if data[0] == "switch"
    @program_sound.delete(data)   if data[0] == "sound"
    @program_se.delete(data)	  if data[0] == "keep_se"
    @program_shake.delete(data)   if data[0] == "keep_sk"
    @program_color.delete(data)   if data[0] == "keep_c"
  end
   end
 end
 #--------------------------------------------------------------------------
 # ● バトルプログラムの開始
 #--------------------------------------------------------------------------
 def program_start?(data)
   start = false
   start = true if $game_switches[data[1].abs] && data[1] > 0
   start = true if @switches[data[1].abs] && data[1] < 0
   return start
 end 
 #--------------------------------------------------------------------------
 # ● バトルプログラム スイッチ操作の開始
 #--------------------------------------------------------------------------
 def start_program_switch(data)
   data[4] = data[4] + rand(data[5] + 1)
   data[4] = 1 if data[4] <= 0
   @program_switch.push(data)
 end
 #--------------------------------------------------------------------------
 # ● スイッチ操作の更新
 #--------------------------------------------------------------------------
 def update_program_switch
   for data in @program_switch
  data[4] -= 1
  next @program_switch.delete(data) if data[1] > 0 && !$game_switches[data[1]]
  next @program_switch.delete(data) if data[1] < 0 && !@switches[data[1].abs]
  next if data[4] != 0
  for id in data[2]
    $game_switches[id] = true if id > 0
    @switches[id.abs] = true  if id < 0
  end
  for id in data[3]
    $game_switches[id] = false if id > 0
    @switches[id.abs] = false  if id < 0
  end
  @program_switch.delete(data)
  program_check
   end 
 end
 #--------------------------------------------------------------------------
 # ● バトルプログラム BGM/BGSの開始
 #--------------------------------------------------------------------------
 def start_sound(data)
   @program_sound.push(data)
   name = data[5]
   case data[2]
   when "se"
  Audio.se_play("Audio/SE/" + name, data[4], data[3])
   when "bgm"
  name = RPG::BGM.last.name if data[5] == ""
  Audio.bgm_play("Audio/BGM/" + name, data[4], data[3])
   when "bgs"
  name = RPG::BGS.last.name if data[5] == ""
  Audio.bgs_play("Audio/BGS/" + name, data[4], data[3])
   end
 end
 #--------------------------------------------------------------------------
 # ● バトルプログラム 周期SEの開始
 #--------------------------------------------------------------------------
 def start_program_se(data)
   data[3] = [data[2], data[3]]
   data[2] = data[3][0] + rand(data[3][1] + 1)
   @program_se.push(data)
   Audio.se_play("Audio/SE/" + data[7], data[5], data[4]) if data[6]
 end
 #--------------------------------------------------------------------------
 # ● 周期SEの更新
 #--------------------------------------------------------------------------
 def update_program_se
   for data in @program_se
  data[2] -= 1
  next @program_se.delete(data) if data[1] > 0 && !$game_switches[data[1]]
  next @program_se.delete(data) if data[1] < 0 && !@switches[data[1].abs]
  next if data[2] != 0
  Audio.se_play("Audio/SE/" + data[7], data[5], data[4])
  data[2] = data[3][0] + rand(data[3][1] + 1)
   end 
 end
 #--------------------------------------------------------------------------
 # ● バトルプログラム 周期シェイクの開始
 #--------------------------------------------------------------------------
 def start_program_shake(data)
   data[3] = [data[2], data[3]]
   data[2] = data[3][0] + rand(data[3][1] + 1)
   @program_shake.push(data)
   shake(data[4], data[5], data[6]) if data[7]
 end
 #--------------------------------------------------------------------------
 # ● 周期シェイクの更新
 #--------------------------------------------------------------------------
 def update_program_shake
   for data in @program_shake
  data[2] -= 1
  next @program_shake.delete(data) if data[1] > 0 && !$game_switches[data[1]]
  next @program_shake.delete(data) if data[1] < 0 && !@switches[data[1].abs]
  next if data[2] != 0
  shake(data[4], data[5], data[6])
  data[2] = data[3][0] + rand(data[3][1] + 1)
   end 
 end
 #--------------------------------------------------------------------------
 # ● バトルプログラム 周期色調変更の開始
 #--------------------------------------------------------------------------
 def start_program_color(data)
   data[3] = [data[2], data[3]]
   data[2] = data[3][0] + rand(data[3][1] + 1)
   data[7] = true if data[4] == 0 or data[4] == 4
   case data[4]
   when 1   ;data[4] = $game_troop.members
   when 2   ;data[4] = $game_party.battle_members
   when 3,4 ;data[4] = $game_troop.members + $game_party.battle_members
   else ;data[4] = []
   end
   @program_color.push(data)
   return if !data[6]
   for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
   @color_set[1] = data[5] if data[7]
   @color_set[2] = data[5] if data[7]
 end
 #--------------------------------------------------------------------------
 # ● 周期色調変更の更新
 #--------------------------------------------------------------------------
 def update_program_color
   for data in @program_color
  data[2] -= 1
  next @program_color.delete(data) if data[1] > 0 && !$game_switches[data[1]]
  next @program_color.delete(data) if data[1] < 0 && !@switches[data[1].abs]
  next if data[2] != 0
  for target in data[4] do target.sv.color_set = data[5] end if data[4] != []
  @color_set[1] = data[5] if data[7]
  @color_set[2] = data[5] if data[7]
  data[2] = data[3][0] + rand(data[3][1] + 1)
   end
 end
 #--------------------------------------------------------------------------
 # ● トランジション実行
 #--------------------------------------------------------------------------
 def perform_transition(data)
   Graphics.transition(data[2], "Graphics/Pictures/" + data[3], data[1])
 end 
 #--------------------------------------------------------------------------
 # ● 背景からカメラの限界値を取得  data = [max_top, max_bottom, max_left, max_right]
 #--------------------------------------------------------------------------
 def setting(index, data)
   @max_data[index - 1] = data
   return if index != 2
   setup
   # カメラの中心座標
   @center_x	 = (Graphics.width / 2 + N03::CAMERA_POSITION[0]) * 100
   @center_y	 = (Graphics.height / 2 + N03::CAMERA_POSITION[1]) * 100
   # 上下左右の移動限界距離
   @max_top    = [@max_data[0][5], @max_data[1][5]].min * -1
   @max_bottom = [@max_data[0][1], @max_data[1][1]].min + @max_top
   @max_left   = [@max_data[0][4], @max_data[1][4]].min  * -1
   @max_right  = [@max_data[0][3], @max_data[1][3]].min + @max_left
   exist_data = @max_data[0] if !@max_data[1][6]
   exist_data = @max_data[1] if !@max_data[0][6]
   @max_top    = exist_data[5] * -1	    if exist_data != nil
   @max_bottom = exist_data[1] + @max_top  if exist_data != nil
   @max_left   = exist_data[4] * -1	    if exist_data != nil
   @max_right  = exist_data[3] + @max_left if exist_data != nil
   @max_top = @max_bottom = @max_left = @max_right = 0 if !@max_data[1][6] && !@max_data[0][6]
   @max_width    = @max_right - @max_left + Graphics.width
   @max_height   = @max_bottom - @max_top + Graphics.height
   # ズームアウト限界値
   max_zoom_x    = 100 * Graphics.width / @max_width
   max_zoom_y    = 100 * Graphics.height / @max_height
   @max_zoom_out = [max_zoom_x, max_zoom_y].max
 end
 #--------------------------------------------------------------------------
 # ● カメラ移動
 #--------------------------------------------------------------------------
 def move(target_x, target_y, zoom, time, screen = true)
   # 戦闘背景以上のサイズまでズームアウトしないよう調整
   @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max
   target_x *= -1 if screen && @mirror
   # ズーム分の中心座標補正
   if screen && @target_zoom != 1
  target_x = target_x + @center_x
  target_y = target_y + @center_y
   end
   adjust_x = @center_x * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
   adjust_y = @center_y * (@target_zoom - 1) / (@target_zoom ** 2 - @target_zoom)
   adjust_x = 0 if adjust_x.nan?
   adjust_y = 0 if adjust_y.nan?
   adjust_x = @center_x if !screen && adjust_x == 0
   adjust_y = @center_y if !screen && adjust_y == 0
   @target_x = target_x - adjust_x.to_i
   @target_y = target_y - adjust_y.to_i
   @target_zoom = (@target_zoom * 1000).to_i
   @zoom = @zoom.to_i
   limit_test
   # 時間0の場合は即実行
   return @time = time.abs if time != 0
   @time = 1
   update
 end
 #--------------------------------------------------------------------------
 # ● 限界座標の試算
 #--------------------------------------------------------------------------
 def limit_test
   new_width = @max_width * @target_zoom / 1000
   new_height = @max_height * @target_zoom / 1000
   new_max_right = @max_right - (@max_width - new_width)
   new_max_bottom = @max_bottom - (@max_height - new_height)
   # 画面の移動先が限界の場合、限界座標をセット
   if @target_x < @max_left * 100
  @target_x = @max_left * 100
   end
   if @target_x > new_max_right * 100
  @target_x = new_max_right * 100
   end
   if @target_y < @max_top * 100
  @target_y = @max_top * 100
   end
   if @target_y > new_max_bottom * 100
  @target_y = new_max_bottom * 100
   end
 end
 #--------------------------------------------------------------------------
 # ● 画面のシェイク
 #--------------------------------------------------------------------------
 def shake(power, speed, time)
   @shake_x = power[0] * 100
   @shake_y = power[1] * 100
   @power_time_base = @power_time = speed
   @shake_time = time
   update_shake
 end
 #--------------------------------------------------------------------------
 # ● シェイクの更新
 #--------------------------------------------------------------------------
 def update_shake
   @sx = (@sx * (@power_time - 1) + @shake_x) / @power_time
   @sy = (@sy * (@power_time - 1) + @shake_y) / @power_time
   @power_time -= 1
   @shake_time -= 1
   return @sx = @sy = 0 if @shake_time == 0
   return if @power_time != 0
   @power_time = @power_time_base
   @shake_x = @shake_x * -4 / 5
   @shake_y = @shake_y * -4 / 5
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新
 #--------------------------------------------------------------------------
 def update
   update_shake if @shake_time != 0
   update_program
   return if @time == 0
   @x = (@x * (@time - 1) + @target_x) / @time
   @y = (@y * (@time - 1) + @target_y) / @time
   @zoom = (@zoom * (@time - 1) + @target_zoom) / @time
   @time -= 1
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新
 #--------------------------------------------------------------------------
 def update_program
   update_program_switch if @program_switch != []
   update_program_se	 if @program_se != []
   update_program_shake  if @program_shake != []
   update_program_color  if @program_color != []
 end
end

 

La riga 300: @target_zoom = [zoom * 0.01, @max_zoom_out * 0.01].max

mi da errore:script battle_camera no method error occurred undefined method '*' for nil:Nilclass

 

Ps: come si mettono gli spoiler?

[Mappa Intro by Dilos]

Eccolo qui lo script *-* bravo mi è stato molto utile U_U

[Sportello Aiuti Veloci VX]

Vero non ci avevo fatto caso!

[C'è uno script per inserire un'intro?]

Sisi risolto avevo messo il call script DOPO la schermata dei titoli grazie ^^

[Sportello Aiuti Veloci VX]

Si per il secondo p ma a me serve il primo! è lui il più ingombrante!

[Sportello Aiuti Veloci VX]

% sarebbe tipo un pronome ( si ho spiegato male ) ES: % perde = "La squadra di eric" perde (quello tra " " sarebbe il % )

D: sullo script http://www.rpg2s.net/forum/index.php?showtopic=14324&st=0 quello dei 2 player come cambio i movimenti di entrambi?

perchè il secondo si muove con wasd e il primo seleziona con zx ed è un poco ingombrante!

[C'è uno script per inserire un'intro?]

Grazie... comunque non mi sta funzionando mò vedo il perchè...

Ma quando dici alla prima linea del main al posto di rgss_main?

Cmq mi dà solo un problema quando finisce l'evento me lo rifà tutto da capo e ho messo torna ai titoli

e l'evento è un inizio automatico

[Diversi Tile?]

I tile dello spazio non li ho trovati mi servirebbe pure un aereonave a mò di nave spaziale

[C'è uno script per inserire un'intro?]

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs the title screen processing.
#==============================================================================
class Scene_Title < Scene_Base
 #--------------------------------------------------------------------------
 # * Start Processing
 #--------------------------------------------------------------------------
 def start
super
SceneManager.clear
Graphics.freeze
create_background
create_foreground
create_command_window
play_title_music
 end
 #--------------------------------------------------------------------------
 # * Get Transition Speed
 #--------------------------------------------------------------------------
 def transition_speed
return 20
 end
 #--------------------------------------------------------------------------
 # * Termination Processing
 #--------------------------------------------------------------------------
 def terminate
super
SceneManager.snapshot_for_background
dispose_background
dispose_foreground
 end
 #--------------------------------------------------------------------------
 # * Create Background
 #--------------------------------------------------------------------------
 def create_background
@sprite1 = Sprite.new
@sprite1.bitmap = Cache.title1($data_system.title1_name)
@sprite2 = Sprite.new
@sprite2.bitmap = Cache.title2($data_system.title2_name)
center_sprite(@sprite1)
center_sprite(@sprite2)
 end
 #--------------------------------------------------------------------------
 # * Create Foreground
 #--------------------------------------------------------------------------
 def create_foreground
@foreground_sprite = Sprite.new
@foreground_sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)
@foreground_sprite.z = 100
draw_game_title if $data_system.opt_draw_title
 end
 #--------------------------------------------------------------------------
 # * Draw Game Title
 #--------------------------------------------------------------------------
 def draw_game_title
@foreground_sprite.bitmap.font.size = 48
rect = Rect.new(0, 0, Graphics.width, Graphics.height / 2)
@foreground_sprite.bitmap.draw_text(rect, $data_system.game_title, 1)
 end
 #--------------------------------------------------------------------------
 # * Free Background
 #--------------------------------------------------------------------------
 def dispose_background
@sprite1.bitmap.dispose
@sprite1.dispose
@sprite2.bitmap.dispose
@sprite2.dispose
 end
 #--------------------------------------------------------------------------
 # * Free Foreground
 #--------------------------------------------------------------------------
 def dispose_foreground
@foreground_sprite.bitmap.dispose
@foreground_sprite.dispose
 end
 #--------------------------------------------------------------------------
 # * Move Sprite to Screen Center
 #--------------------------------------------------------------------------
 def center_sprite(sprite)
sprite.ox = sprite.bitmap.width / 2
sprite.oy = sprite.bitmap.height / 2
sprite.x = Graphics.width / 2
sprite.y = Graphics.height / 2
 end
 #--------------------------------------------------------------------------
 # * Create Command Window
 #--------------------------------------------------------------------------
 def create_command_window
@command_window = Window_TitleCommand.new
@command_window.set_handler(:new_game, method(:command_new_game))
@command_window.set_handler(:continue, method(:command_continue))
@command_window.set_handler(:shutdown, method(:command_shutdown))
 end
 #--------------------------------------------------------------------------
 # * Close Command Window
 #--------------------------------------------------------------------------
 def close_command_window
@command_window.close
update until @command_window.close?
 end
 #--------------------------------------------------------------------------
 # * [New Game] Command
 #--------------------------------------------------------------------------
 def command_new_game
DataManager.setup_new_game
close_command_window
fadeout_all
$game_map.autoplay
SceneManager.goto(Scene_Map)
 end
 #--------------------------------------------------------------------------
 # * [Continue] Command
 #--------------------------------------------------------------------------
 def command_continue
close_command_window
SceneManager.call(Scene_Load)
 end
 #--------------------------------------------------------------------------
 # * [shut Down] Command
 #--------------------------------------------------------------------------
 def command_shutdown
close_command_window
fadeout_all
SceneManager.exit
 end
 #--------------------------------------------------------------------------
 # * Play Title Screen Music
 #--------------------------------------------------------------------------
 def play_title_music
$data_system.title_bgm.play
RPG::BGS.stop
RPG::ME.stop
 end
end

[Diversi Tile?]

Mi servirebbero dei tileset dello spazio (universo)

vi faccio un'esempio nei giochi la mappa del mondo rareste dei giganti e le città piccoline ci camminate sopra e entrare

in quelle poi fatte grandi.

Invece delle città a me servono le immagini dei mondi.

Poi avevo visto un sito dove c'erano tutti i tile di tutti i the legend of zelda, me lo linkate o mandate tramite mp?

Grazie :D

[C'è uno script per inserire un'intro?]

Mi dice che in Data mi manca actors.rvdata

ma c'el'ho

 

EDIT: scusate il doppio post mi sono dimenticato :S

[C'è uno script per inserire un'intro?]

Quante risposte O_O

Non avevo controllato

Cmq sto testando

[C'è uno script per inserire un'intro?]

Potendo anche video ma non li ho mai visti in .ogg

Cmq c'è un tipo Intro Scene Reloaded come su vx ( se non sbaglio) ?

[Sono qui! :D]

[Barra PV ai nemici]

Per il momento mi pare ci sia solo per YEA, ma il battle engine non è poi così brutto!

[Sportello aiuti veloci VX-Ace]

Anzi.... ho risolto... bastava settare un pò quà e un pò là cmq grazie.