语法问题，如何将一个代码块框起来？

七重 · 发表于 2016-2-10 23:24:39

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有账号？注册会员

×

本帖最后由七重于 2016-2-10 23:57 编辑

如何将一个代码块框起来？

遇到两个脚本冲突。
因为其中一个脚本只在一张地图用到。
所以我打算用开关控制是否运行这两个脚本。

当某个开关打开时才执行脚本。
↓
==================================

if $game_switches[？？] == ture
{
想控制的脚本代码
}

==================================

这个是错的。
记得以前好像看过是有这么一个写法的，但是又记不清楚具体怎么写，正确的写法应该是什么呢。。？

这个问题好像很小白。。但是没有找到。。十分抱歉又来伸手

喵呜喵5 · 发表于 2016-2-11 00:18:44

若脚本本身没提供相应的功能的话
除非你看得懂该脚本，否则请不要这么进行尝试

七重 · 发表于 2016-2-11 08:02:11

本帖最后由七重于 2016-2-11 08:08 编辑

喵呜喵5 发表于 2016-2-11 00:18
若脚本本身没提供相应的功能的话
除非你看得懂该脚本，否则请不要这么进行尝试 ...

好像是有点乱来。。

出现冲突的脚本是：
ulds，
Khas Awesome Light Effects
以及一个没有作者信息的脚本layer，效果是将多个地图的内容在一个地图分层显示，效果和立交桥脚本差不多。附上代码。
（有冲突的就是第三个，其实和很多脚本冲突，之前本来放弃用这个了，但是这个效果有点炫啊。。所以想要抢救一下）

layer代码

#这是某天在6r上面拉下来的脚本。本身就没有标注作者信息
#==============================================================================
# ■ Game_System
#------------------------------------------------------------------------------
# 　システム周りのデータを扱うクラスです。乗り物や BGM などの管理も行います。
# このクラスのインスタンスは $game_system で参照されます。
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :layer # レイヤー
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias game_system_initialize initialize
def initialize
game_system_initialize
@layer = -1
end
end
#==============================================================================
# ■ Game_Temp
#------------------------------------------------------------------------------
# 　セーブデータに含まれない、一時的なデータを扱うクラスです。このクラスのイン
# スタンスは $game_temp で参照されます。
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# ● 定数
#--------------------------------------------------------------------------
MAX_LAYER = 5 # レイヤの最大数
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :map_name #再読み込み回避
attr_accessor :link_array #再読み込み回避
attr_accessor :check #再読み込み回避
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias game_temp_initialize initialize
def initialize
game_temp_initialize
@map_name = [] #再読み込み回避
@link_array = [[0]] #再読み込み回避
@check = false #再読み込み回避
create_link_data
end
#--------------------------------------------------------------------------
# ● マップの親ＩＤを探す
#--------------------------------------------------------------------------
def get_parent_map_id(map_id)
return @link_array[map_id][0]
end
#--------------------------------------------------------------------------
# ● リンク配列を作成する。
#--------------------------------------------------------------------------
def create_link_data
return if @check
return if $BTEST
range = 0..MAX_LAYER-1
id_array = []
$data_mapinfos.each do | i,data |
@map_name[i] = data.name
id_array.push(i)
end
id_array.each do | id |
buf = []
name = @map_name[id].gsub(/\<(\w+)\>/,"")
name = name.gsub(/\[(\w+)\]/,"")
id_array.each do |id2|
temp_name = @map_name[id2]
if temp_name.match(name) && temp_name.match(/\<lay(\d+)\>/)
buf[$1.to_i] = id2
end
end
buf[0] = id if buf[0] == nil
@link_array[id] = buf
end
@check = true
end
end
#==============================================================================
# ■ Game_Map
#------------------------------------------------------------------------------
# 　マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。
# このクラスのインスタンスは $game_map で参照されます。
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# ● 定数
#--------------------------------------------------------------------------
MAX_EVENT = 1000 # 1レイヤ当たりのイベント数
MAX_LAYER = 5 # レイヤの最大数
LAYER_UP = 1022 # レイヤを上げるチップID
LAYER_DW = 1023 # レイヤを下げるチップID
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :name
attr_accessor :para_layer
attr_accessor :spe_layer
attr_reader :spe_picture_name
attr_reader :spe_picture_layer
attr_reader :fog_name # フォグファイル名
attr_reader :map_lay
#--------------------------------------------------------------------------
# ● セットアップ
# map_id : マップ ID
# enable : 所属レイヤーの変更
#--------------------------------------------------------------------------
def setup(map_id,enable=false)
#########################################################################
#レイヤー
@map_id = map_id
@name = $data_mapinfos[@map_id].name
@map_lay = [] #各レイヤーのマップデータ
@layer_no = 0
$game_player.set_active_layer(0)
@pl_layer = 0
@name.gsub(/\<lay(\d+)\>/i) { @pl_layer = enable || $game_system.layer == -1 ? $1.to_i : $game_system.layer }
$game_player.set_active_layer(@pl_layer)
$game_player.link_layer_followers #フォロワーのレイヤーをリンク
@layer_num = $game_temp.link_array[@map_id].size
@map_id = $game_temp.link_array[@map_id][0]
#リンクするマップをレイヤーとして読み込む
@spe_picture_name = ""
@para_layer = 0
$game_temp.link_array[@map_id].each do | id |
@map_lay.push(load_data(sprintf("Data/Map%03d.rvdata2",id)))
link_name = $game_temp.map_name[id]
link_id = $game_temp.link_array[@map_id].index(id)
link_name.gsub(/<para>/) { @para_layer = link_id }
link_name.gsub(/\[(\w+)\]/){ set_spe_picture(link_id,$1) }
end
set_layer_no(0)
@map_lay.each { |map| map.display_name = @map_lay[0].display_name }
@display_x = [0,0,0,0,0]
@display_y = [0,0,0,0,0]
@speed_x = [0,0,0,0,0]
@speed_y = [0,0,0,0,0]
#########################################################################
@tileset_id = []
@map_lay.each {|map| @tileset_id.push(map.tileset_id)}
referesh_vehicles
setup_events
setup_scroll
setup_parallax
setup_fog
setup_battleback
setup_event_list
@need_refresh = false
end
#--------------------------------------------------------------------------
# ● フレーム更新
# main : インタプリタ更新フラグ
#--------------------------------------------------------------------------
def update(main = false)
refresh if @need_refresh
update_interpreter if main
update_scroll
update_move_layer
update_events
update_event_list
update_vehicles
update_parallax
update_fog
@screen.update
end
#--------------------------------------------------------------------------
# ● タイルセットの取得
#--------------------------------------------------------------------------
def tileset(lay=0)
$data_tilesets[@tileset_id[lay]]
end
#--------------------------------------------------------------------------
# ● イベントのセットアップ
#--------------------------------------------------------------------------
def setup_events
@events = {}
@map_lay.each_with_index do | map,index |
map.events.each do |i, event|
event.id += MAX_EVENT*index
@events[i+MAX_EVENT*index] = Game_Event.new(@map_id, event)
end
end
@common_events = parallel_common_events.collect do |common_event|
Game_CommonEvent.new(common_event.id)
end
refresh_tile_events
end
#--------------------------------------------------------------------------
# ● キャラクターを優先順位が低い順に並べた配列を生成する。
#--------------------------------------------------------------------------
def setup_event_list
@atari_array = []
#イベントの場合
$game_map.events.each_value do |ev|
next if ev.event.name.index("接続イベント")
@atari_array.push(ev)
end
#乗り物の場合
$game_map.vehicles.each do |vehicle|
@atari_array.push(vehicle)
end
#フォロワーの場合
$game_player.followers.reverse_each do |follower|
@atari_array.push(follower)
end
#プレイヤーの場合
@atari_array.push($game_player)
end
#--------------------------------------------------------------------------
# ● キャラクターを優先順位が低い順に並べた配列を生成する。
#--------------------------------------------------------------------------
def update_event_list
return unless SceneManager.scene_is?(Scene_Map)
sprite_ctrl = SceneManager.scene.spriteset
return if sprite_ctrl == nil
return if sprite_ctrl.spriteset.size != get_layer_num
@pri_array = []
@atari_array.each do |ev|
if ev.instance_of?(Game_Event) || ev.instance_of?(Game_Vehicle)
@pri_array.push(ev) if ev.pre_hit?
else
@pri_array.push(ev)
end
end
@pri_array.sort! {|a,b| a.priority_type*1000000 + a.y*100000 + d_sprite(a).z*100 + a.sprite_id <=> b.priority_type*1000000 + b.y*100000 + d_sprite(b).z*100 + b.sprite_id}
end
#--------------------------------------------------------------------------
# ● キャラクターを優先順位が低い順に並べた配列を取得する。
#--------------------------------------------------------------------------
def event_list
@pri_array
end
#--------------------------------------------------------------------------
# ● イベントに対応したスプライト
#--------------------------------------------------------------------------
def d_sprite(ev)
sprite_ctrl = SceneManager.scene.spriteset
return sprite_ctrl.spriteset[ev.active_layer].character_sprites[ev.sprite_id]
end
#--------------------------------------------------------------------------
# ● 乗っているタイルＩＤを取得する
#--------------------------------------------------------------------------
def get_chip_id(x=$game_player.x,y=$game_player.y,layer=0)
[2, 1, 0].each do |i|
tile_id = @map_lay[layer].data[x, y, i]
return tile_id if tile_id != 0 # タイル ID 取得できたら終了
end
return nil
end
#--------------------------------------------------------------------------
# ● 取得するレイヤーNoの設定
#--------------------------------------------------------------------------
def set_layer_no(no)
@layer_no = no
@layer_no %= @layer_num
@layer_no = 0 if @layer_no < 0
@map = @map_lay[@layer_no]
end
#--------------------------------------------------------------------------
# ● レイヤー数の取得
#--------------------------------------------------------------------------
def get_layer_num
return @layer_num
end
#--------------------------------------------------------------------------
# ● リージョン ID の取得
#--------------------------------------------------------------------------
def region_id(x, y, layer=$game_player.active_layer)
valid?(x, y) ? @map_lay[layer].data[x, y, 3] >> 8 : 0
end
#--------------------------------------------------------------------------
# ● エンカウントリストの取得
#--------------------------------------------------------------------------
def encounter_list
@map_lay[$game_player.active_layer].encounter_list
end
#--------------------------------------------------------------------------
# ● エンカウント歩数の取得
#--------------------------------------------------------------------------
def encounter_step
@map_lay[$game_player.active_layer].encounter_step
end
#--------------------------------------------------------------------------
# ● マップデータの取得
#--------------------------------------------------------------------------
def data
return @map_lay[@layer_no].data
end
#--------------------------------------------------------------------------
# ● 指定座標に存在するタイル扱いイベント（すり抜け以外）の配列取得
#--------------------------------------------------------------------------
def tile_events_xy(x, y, layer=0)
@tile_events.select {|event| event.pos_nt?(x, y) && event.active_layer==layer }
end
#--------------------------------------------------------------------------
# ● 指定座標にある全てのタイル（イベント含む）を配列で取得
#--------------------------------------------------------------------------
def all_tiles(x, y, layer=0)
tile_events_xy(x, y, layer).collect {|ev| ev.tile_id} + layered_tiles(x, y)
end
#--------------------------------------------------------------------------
# ● 通行可能判定
# x : X 座標
# y : Y 座標
# flag : 調べる通行禁止ビット (通常 0x01、乗り物の場合のみ変更)
#--------------------------------------------------------------------------
def passable?(x, y, d, active_layer=0)
check_passage(x, y, (1 << (d / 2 - 1)) & 0x0f, active_layer)
end
#--------------------------------------------------------------------------
# ● 小型船の通行可能判定
#--------------------------------------------------------------------------
def boat_passable?(x, y, active_layer=0)
check_passage(x, y, 0x0200, active_layer)
end
#--------------------------------------------------------------------------
# ● 大型船の通行可能判定
#--------------------------------------------------------------------------
def ship_passable?(x, y, active_layer=0)
check_passage(x, y, 0x0400, active_layer)
end
#--------------------------------------------------------------------------
# ● 通行チェック
# bit : 調べる通行禁止ビット
#--------------------------------------------------------------------------
def check_passage(x, y, bit, active_layer=0)
set_layer_no(active_layer)
if bit == 0x0200 || bit == 0x0400
if LAYER_DW == tile_id(x,y,2) || LAYER_UP == tile_id(x,y,2)
return true
end
end
check_layer = active_layer
#上レイヤーの接続チップは"上"のみチェック
if LAYER_UP == tile_id(x,y,2)
check_layer += 1
elsif LAYER_DW == tile_id(x,y,2)
check_layer -= 1
end
set_layer_no(check_layer)
all_tiles(x, y, check_layer).each do |tile_id|
flag = tileset(check_layer).flags[tile_id]
next if flag & 0x10 != 0 # [☆] : 通行に影響しない
if flag & bit == 0 # [○] : 通行可
set_layer_no(active_layer)
return true
end
if flag & bit == bit # [×] : 通行不可
set_layer_no(active_layer)
return false
end
end
set_layer_no(active_layer)
return false # 通行不可
end
#--------------------------------------------------------------------------
# ● 横方向にループするか？
#--------------------------------------------------------------------------
def loop_horizontal?(lay=0)
return false if lay > @layer_num-1
return (@map_lay[lay].scroll_type == 2 or @map_lay[lay].scroll_type == 3)
end
#--------------------------------------------------------------------------
# ● 縦方向にループするか？
#--------------------------------------------------------------------------
def loop_vertical?(lay=0)
return false if lay > @layer_num-1
return (@map_lay[lay].scroll_type == 1 or @map_lay[lay].scroll_type == 3)
end
#--------------------------------------------------------------------------
# ● ダッシュ禁止か否かの取得
#--------------------------------------------------------------------------
def disable_dash?
return @map_lay[0].disable_dashing
end
#--------------------------------------------------------------------------
# ● 遠景のセットアップ
#--------------------------------------------------------------------------
alias setup_parallax_game_map setup_parallax
def setup_parallax
old_map = @map
@map = @map_lay[@para_layer]
setup_parallax_game_map
@map = old_map
end
#--------------------------------------------------------------------------
# ● タイルセットの変更
#--------------------------------------------------------------------------
def change_tileset(tileset_id)
@tileset_id.each_with_index do |t,i|
if @tileset_id != nil
@tileset_id[i] = tileset_id
end
end
refresh
end
#--------------------------------------------------------------------------
# ● BGM / BGS 自動切り替え
#--------------------------------------------------------------------------
alias autoplay_game_map autoplay
def autoplay
old_map = @map
@map = @map_lay[0]
autoplay_game_map
@map = old_map
end
#--------------------------------------------------------------------------
# ● 茂み判定
# x : X 座標
# y : Y 座標
#--------------------------------------------------------------------------
def bush?(x, y, layer=0)
@map = @map_lay[layer]
valid?(x, y) && layered_tiles_flag?(x, y, 0x40)
end
#--------------------------------------------------------------------------
# ● 地形タグの取得
#--------------------------------------------------------------------------
alias terrain_tag_layer terrain_tag
def terrain_tag(x, y, layer=0)
@map = @map_lay[layer]
terrain_tag_layer(x, y)
end
#--------------------------------------------------------------------------
# ● カウンター判定
# x : X 座標
# y : Y 座標
#--------------------------------------------------------------------------
def counter?(x, y, layer=0)
@map = @map_lay[layer]
valid?(x, y) && layered_tiles_flag?(x, y, 0x80)
end
#--------------------------------------------------------------------------
# ● レイヤースクロール
#--------------------------------------------------------------------------
def set_move_layer(lay,speed_x,speed_y)
@speed_x[lay] = speed_x
@speed_y[lay] = speed_y
end
#--------------------------------------------------------------------------
# ● レイヤースクロール
#--------------------------------------------------------------------------
def update_move_layer
return if scrolling? #通常のスクロール処理が行われている
# return unless scrolling?
@speed_x.each_with_index do | x,i |
a_x = x
# a_x += @speed_x[$game_player.active_layer] if $game_player.active_layer != i
if a_x > 0
scroll_left(2 ** a_x.abs / 256.0,i)
elsif a_x < 0
scroll_right(2 ** a_x.abs / 256.0,i)
end
end
@speed_y.each_with_index do | y,i |
a_y = y
# a_y += @speed_y[$game_player.active_layer] if $game_player.active_layer != i
if a_y > 0
scroll_up(2 ** a_y.abs / 256.0,i)
elsif a_y < 0
scroll_down(2 ** a_y.abs / 256.0,i)
end
end
end
#--------------------------------------------------------------------------
# ● 表示位置の設定
# x : 新しい表示 X 座標 (*256)
# y : 新しい表示 Y 座標 (*256)
#--------------------------------------------------------------------------
def set_display_pos(x, y)
range = 0..4
range.each do | i |
x = [0, [x, width - screen_tile_x].min].max unless loop_horizontal?(i)
y = [0, [y, height - screen_tile_y].min].max unless loop_vertical?(i)
@display_x[i] = (x + width) % width
@display_y[i] = (y + height) % height
end
@parallax_x = x
@parallax_y = y
range.each do | i |
@fog_x[i] = x
@fog_y[i] = y
end
end
#--------------------------------------------------------------------------
# ● 表示座標を差し引いた X 座標の計算
# x : X 座標
#--------------------------------------------------------------------------
def adjust_x(x,lay=0)
if loop_horizontal?(lay) && x < @display_x[lay] - (width - screen_tile_x) / 2
x - @display_x[lay] + @map.width
else
x - @display_x[lay]
end
end
#--------------------------------------------------------------------------
# ● 表示座標を差し引いた Y 座標の計算
# y : Y 座標
#--------------------------------------------------------------------------
def adjust_y(y,lay=0)
if loop_vertical?(lay) && y < @display_y[lay] - (height - screen_tile_y) / 2
y - @display_y[lay] + @map.height
else
y - @display_y[lay]
end
end
#--------------------------------------------------------------------------
# ● 下にスクロール
# distance : スクロールする距離
#--------------------------------------------------------------------------
def scroll_down(distance,lay=-1)
range = lay==-1 ? 0..4 : lay..lay
range.each do | i |
if loop_vertical?(i)
@display_y[i] += distance
@display_y[i] %= @map.height
@parallax_y += distance if @parallax_loop_y && i==@para_layer
@fog_y[i] += distance
else
last_y = @display_y[i]
@display_y[i] = [@display_y[i] + distance, height - screen_tile_y].min
@parallax_y += @display_y[i] - last_y if i==@para_layer
@fog_y[i] += @display_y[i] - last_y
end
end
end
#--------------------------------------------------------------------------
# ● 左にスクロール
# distance : スクロールする距離
#--------------------------------------------------------------------------
def scroll_left(distance,lay=-1)
range = lay==-1 ? 0..4 : lay..lay
range.each do | i |
if loop_horizontal?(i)
@display_x[i] += @map.width - distance
@display_x[i] %= @map.width
@parallax_x -= distance if @parallax_loop_x && i==@para_layer
@fog_x[i] -= distance
else
last_x = @display_x[i]
@display_x[i] = [@display_x[i] - distance, 0].max
@parallax_x += @display_x[i] - last_x if i==@para_layer
@fog_x[i] += @display_x[i] - last_x
end
end
end
#--------------------------------------------------------------------------
# ● 右にスクロール
# distance : スクロールする距離
#--------------------------------------------------------------------------
def scroll_right(distance,lay=-1)
range = lay==-1 ? 0..4 : lay..lay
range.each do | i |
if loop_horizontal?(i)
@display_x[i] += distance
@display_x[i] %= @map.width
@parallax_x += distance if @parallax_loop_x && i==@para_layer
@fog_x[i] += distance
else
last_x = @display_x[i]
@display_x[i] = [@display_x[i] + distance, (width - screen_tile_x)].min
@parallax_x += @display_x[i] - last_x if i==@para_layer
@fog_x[i] += @display_x[i] - last_x
end
end
end
#--------------------------------------------------------------------------
# ● 上にスクロール
# distance : スクロールする距離
#--------------------------------------------------------------------------
def scroll_up(distance,lay=-1)
range = lay==-1 ? 0..4 : lay..lay
range.each do | i |
if loop_vertical?(i)
@display_y[i] += @map.height - distance
@display_y[i] %= @map.height
@parallax_y -= distance if @parallax_loop_y if i==@para_layer
@fog_y[i] -= distance
else
last_y = @display_y[i]
@display_y[i] = [@display_y[i] - distance, 0].max
@parallax_y += @display_y[i] - last_y if i==@para_layer
@fog_y[i] += @display_y[i] - last_y
end
end
end
#--------------------------------------------------------------------------
# ● スクロールの更新
#--------------------------------------------------------------------------
def update_scroll
return unless scrolling?
lay = $game_player.active_layer
last_x = @display_x[lay]
last_y = @display_y[lay]
do_scroll(@scroll_direction, scroll_distance)
if @display_x[lay] == last_x && @display_y[lay] == last_y
@scroll_rest = 0
else
@scroll_rest -= scroll_distance
end
end
#--------------------------------------------------------------------------
# ● 挟み込む特殊ピクチャスプライトを表示
#--------------------------------------------------------------------------
def set_spe_picture(layer,filename)
@spe_picture_name = filename
@spe_picture_layer = layer
end
#--------------------------------------------------------------------------
# ● 挟み込む特殊ピクチャスプライトを表示
#--------------------------------------------------------------------------
def get_spe_picture
return @spe_picture_name
end
#--------------------------------------------------------------------------
# ● 挟み込む特殊ピクチャスプライトを解放
#--------------------------------------------------------------------------
def clear_spe_picture
@spe_picture_name = ""
end
#--------------------------------------------------------------------------
# ● フォグの更新
#--------------------------------------------------------------------------
def update_fog
range = 0..4
range.each do | i |
@fog_x[i] += @fog_sx[i] / 64.0
@fog_y[i] += @fog_sy[i] / 64.0
end
end
#--------------------------------------------------------------------------
# ● フォグ表示 X 座標の計算
# bitmap : 遠景ビットマップ
#--------------------------------------------------------------------------
def fog_ox(bitmap,lay)
@fog_x[lay] * 16
end
#--------------------------------------------------------------------------
# ● フォグ表示 Y 座標の計算
# bitmap : 遠景ビットマップ
#--------------------------------------------------------------------------
def fog_oy(bitmap,lay)
@fog_y[lay] * 16
end
#--------------------------------------------------------------------------
# ● フォグ初期化
#--------------------------------------------------------------------------
def setup_fog
@fog_name = [nil,nil,nil,nil,nil]
@fog_sx = [0,0,0,0,0]
@fog_sy = [0,0,0,0,0]
@fog_x = [0,0,0,0,0]
@fog_y = [0,0,0,0,0]
end
#--------------------------------------------------------------------------
# ● フォグの開始
#--------------------------------------------------------------------------
def start_fog(bitmap,lay,x=0,y=0)
@fog_name[lay] = bitmap
@fog_sx[lay] = x
@fog_sy[lay] = y
end
#--------------------------------------------------------------------------
# ● 幅の取得
#--------------------------------------------------------------------------
def width
@map = @map_lay[0] if @map == nil
@map.width
end
#--------------------------------------------------------------------------
# ● 高さの取得
#--------------------------------------------------------------------------
def height
@map = @map_lay[0] if @map == nil
@map.height
end
end
#==============================================================================
# ■ Scene_Map
#------------------------------------------------------------------------------
# 　マップ画面の処理を行うクラスです。
#==============================================================================
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :spriteset
#--------------------------------------------------------------------------
# ● スプライトセットの作成
#--------------------------------------------------------------------------
def create_spriteset
@spriteset = Spriteset_Map_Ctrl.new
end
#--------------------------------------------------------------------------
# ● 場所移動の処理
#--------------------------------------------------------------------------
def perform_transfer
pre_transfer
$game_player.perform_transfer
dispose_spriteset
create_spriteset
post_transfer
end
end
#==============================================================================
# ■ Spriteset_Map_Ctrl
#------------------------------------------------------------------------------
# 　レイヤー毎に持っているスプライトセットをまとめて管理
#==============================================================================
class Spriteset_Map_Ctrl
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :spriteset
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
def initialize
@spriteset = []
range = 0..$game_map.get_layer_num-1
range.each do |i|
$game_map.set_layer_no(i)
upper_flg = i==$game_map.get_layer_num-1 ? true : false
@spriteset.push(Spriteset_Map.new(i,upper_flg))
end
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
@spriteset.each { | sprite | sprite.update }
end
#--------------------------------------------------------------------------
# ● 終了処理
#--------------------------------------------------------------------------
def dispose
@spriteset.each { | sprite | sprite.dispose }
end
#--------------------------------------------------------------------------
# ● 内部のレイヤースプライトを取得
#--------------------------------------------------------------------------
def get_layer_sprite
return @spriteset
end
#--------------------------------------------------------------------------
# ● キャラクターのスプライトを解放
#--------------------------------------------------------------------------
def dispose_characters
@spriteset.each { | sprite | sprite.dispose_characters }
end
end
#==============================================================================
# ■ Spriteset_Map
#------------------------------------------------------------------------------
# 　マップ画面のスプライトやタイルマップなどをまとめたクラスです。このクラスは
# Scene_Map クラスの内部で使用されます。
#==============================================================================
class Spriteset_Map
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :viewport1
attr_accessor :viewport2
attr_accessor :viewport3
attr_accessor :character_sprites
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
def initialize(pri,top)
@pri = pri
@top = top
create_viewports
create_tilemap
create_parallax if update_parallaxes?
create_fog
create_spe_pic if update_spe?
create_characters
create_shadow if update?
create_weather if update?
create_pictures if update?
create_timer if update?
update
end
#--------------------------------------------------------------------------
# ● 解放
#--------------------------------------------------------------------------
def dispose
dispose_tilemap
dispose_parallax if update_parallaxes?
dispose_fog
dispose_spe_pic if update_spe?
dispose_characters
dispose_attachs
dispose_shadow if update?
dispose_weather if update?
dispose_pictures if update?
dispose_timer if update?
dispose_viewports
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
$game_map.set_layer_no(@pri)
update_tileset
update_tilemap
update_parallax if update_parallaxes?
update_fog
update_spe_pic if update_spe?
update_characters
update_attachs
update_shadow if update?
update_weather if update?
update_pictures if update?
update_timer if update?
update_viewports
end
#--------------------------------------------------------------------------
# ● タイルマップの作成
#--------------------------------------------------------------------------
alias create_tilemap_layer create_tilemap
def create_tilemap
create_tilemap_layer
load_tileset
refresh_tilemap
end
#--------------------------------------------------------------------------
# ● タイルセットのロード
#--------------------------------------------------------------------------
def load_tileset
@tileset = $game_map.tileset(@pri)
@tileset.tileset_names.each_with_index do |name, i|
@tilemap.bitmaps[i] = Cache.tileset(name)
end
@tilemap.flags = @tileset.flags
end
#--------------------------------------------------------------------------
# ● いらないタイルを消す
#--------------------------------------------------------------------------
def refresh_tilemap
if $game_map.get_layer_num > 1
erase_tile(Game_Map::LAYER_UP)
erase_tile(Game_Map::LAYER_DW)
end
end
#--------------------------------------------------------------------------
# ● いらないタイルを消す
#--------------------------------------------------------------------------
def erase_tile(id)
x=(id%8)*32 + 256*(id/888)
y=(id-768)/8*32 - 512*(id/888)
@tilemap.bitmaps[8].clear_rect(x, y, 32, 32)
end
#--------------------------------------------------------------------------
# ● キャラクタースプライトの作成
#--------------------------------------------------------------------------
def create_characters
@character_sprites = []
@attach_sprites = []
sprite_id=0
attach_id=0
$game_map.events.values.each do |event|
if event.event.name.index("接続イベント")
@attach_sprites.push(Sprite_Attach.new(@viewport1, event, @pri))
event.set_sprite_id(attach_id)
attach_id+=1
else
@character_sprites.push(Sprite_Character.new(@viewport1, event, @pri))
event.set_sprite_id(sprite_id)
sprite_id+=1
end
end
$game_map.vehicles.each do |vehicle|
@character_sprites.push(Sprite_Character.new(@viewport1, vehicle, @pri))
vehicle.set_sprite_id(sprite_id)
sprite_id+=1
end
$game_player.followers.reverse_each do |follower|
@character_sprites.push(Sprite_Character.new(@viewport1, follower, @pri))
follower.set_sprite_id(sprite_id)
sprite_id+=1
end
@character_sprites.push(Sprite_Character.new(@viewport1, $game_player, @pri))
$game_player.set_sprite_id(sprite_id)
@map_id = $game_map.map_id
end
#--------------------------------------------------------------------------
# ● キャラクタースプライトの更新
#--------------------------------------------------------------------------
def update_characters
refresh_characters if @map_id != $game_map.map_id
@character_sprites.each {|sprite| sprite.update }
end
#--------------------------------------------------------------------------
# ● アタッチスプライトの更新
#--------------------------------------------------------------------------
def update_attachs
@attach_sprites.each {|sprite| sprite.update }
end
#--------------------------------------------------------------------------
# ● アタッチスプライトの解放
#--------------------------------------------------------------------------
def dispose_attachs
@attach_sprites.each {|sprite| sprite.dispose }
end
#--------------------------------------------------------------------------
# ● アップデートするか？
#--------------------------------------------------------------------------
def update?
@pri==0 ? true : false
end
#--------------------------------------------------------------------------
# ● アップデートするか？(遠景)
#--------------------------------------------------------------------------
def update_parallaxes?
return @pri==$game_map.para_layer ? true : false
end
#--------------------------------------------------------------------------
# ● アップデートするか？(最上層)
#--------------------------------------------------------------------------
def update_top?
return @top
end
#--------------------------------------------------------------------------
# ● アップデートするか？(挟み込むピクチャ)
#--------------------------------------------------------------------------
def update_spe?
return @pri==$game_map.spe_picture_layer ? true : false
end
#--------------------------------------------------------------------------
# ● ビューポートの更新
#--------------------------------------------------------------------------
def update_viewports
if update_top?
@viewport1.tone = $game_map.screen.tone
end
@viewport1.ox = $game_map.screen.shake
if update_top?
@viewport2.color = $game_map.screen.flash_color
@viewport3.color.set(0, 0, 0, 255 - $game_map.screen.brightness)
end
@viewport1.update
@viewport2.update
@viewport3.update
end
#--------------------------------------------------------------------------
# ● タイルマップの更新
#--------------------------------------------------------------------------
def update_tilemap
@tilemap.map_data = $game_map.data
@tilemap.ox = $game_map.display_x[@pri] * 32
@tilemap.oy = $game_map.display_y[@pri] * 32
@tilemap.update
end
#--------------------------------------------------------------------------
# ● 天候の更新
#--------------------------------------------------------------------------
def update_weather
@weather.type = $game_map.screen.weather_type
@weather.power = $game_map.screen.weather_power
@weather.ox = $game_map.display_x[@pri] * 32
@weather.oy = $game_map.display_y[@pri] * 32
@weather.update
end
#--------------------------------------------------------------------------
# ● 挟み込む特殊ピクチャスプライトを作成
#--------------------------------------------------------------------------
def create_spe_pic
@layer_sprite = Sprite.new
@filename = ""
@old_filename = ""
end
#--------------------------------------------------------------------------
# ● 挟み込む特殊ピクチャスプライトを更新
#--------------------------------------------------------------------------
def update_spe_pic
@layer_sprite.update
filename = $game_map.spe_picture_name
if @pri == $game_map.spe_picture_layer && filename != @old_filename
if filename != ""
name = "Graphics/Pictures/" + $game_map.spe_picture_name
@layer_sprite.bitmap = Bitmap.new(name)
@layer_sprite.wave_amp = 5
@layer_sprite.wave_length = 5
@layer_sprite.wave_speed = 20
@layer_sprite.x = -20
@layer_sprite.y = 0
@layer_sprite.z = 0
@layer_sprite.opacity = 200
@layer_sprite.visible = true
else
@layer_sprite.visible = false
end
@old_filename = filename
end
end
#--------------------------------------------------------------------------
# ● 挟み込む特殊ピクチャスプライトを解放
#--------------------------------------------------------------------------
def dispose_spe_pic
@layer_sprite.dispose if @layer_sprite != nil
end
#--------------------------------------------------------------------------
# ● タイルセットの更新
#--------------------------------------------------------------------------
def update_tileset
if @tileset != $game_map.tileset(@pri) #&& $game_map.tileset(@pri) != nil
load_tileset
refresh_characters
refresh_tilemap
end
end
#--------------------------------------------------------------------------
# ● フォグの作成
#--------------------------------------------------------------------------
def create_fog
@fog = Plane.new
@fog.opacity = 100
end
#--------------------------------------------------------------------------
# ● フォグの更新
#--------------------------------------------------------------------------
def update_fog
return if $game_map.fog_name == nil
if @fog_name != $game_map.fog_name[@pri]
@fog_name = $game_map.fog_name[@pri]
@fog.bitmap.dispose if @fog.bitmap
@fog.bitmap = Cache.parallax(@fog_name)
Graphics.frame_reset
end
@fog.ox = $game_map.fog_ox(@fog.bitmap,@pri)
@fog.oy = $game_map.fog_oy(@fog.bitmap,@pri)
end
#--------------------------------------------------------------------------
# ● フォグの解放
#--------------------------------------------------------------------------
def dispose_fog
@fog.bitmap.dispose if @fog.bitmap
@fog.dispose
end
#--------------------------------------------------------------------------
# ● 遠景の解放
#--------------------------------------------------------------------------
def dispose_parallax
return if @parallax == nil
@parallax.bitmap.dispose && @parallax.bitmap
@parallax.dispose
end
end
#==============================================================================
# ■ Game_Player
#------------------------------------------------------------------------------
# 　プレイヤーを扱うクラスです。イベントの起動判定や、マップのスクロールなどの
# 機能を持っています。このクラスのインスタンスは $game_player で参照されます。
#==============================================================================
class Game_Player < Game_Character
#--------------------------------------------------------------------------
# ● マップ通行可能判定
# d : 方向（2,4,6,8）
#--------------------------------------------------------------------------
def map_passable?(x, y, d)
case @vehicle_type
when :boat
$game_map.boat_passable?(x, y, @active_layer)
when :ship
$game_map.ship_passable?(x, y, @active_layer)
when :airship
true
else
super
end
end
#--------------------------------------------------------------------------
# ● 場所移動の実行
#--------------------------------------------------------------------------
def perform_transfer
if transfer?
set_direction(@new_direction)
if @new_map_id != $game_map.map_id
$game_map.setup(@new_map_id,true) # レイヤー間を移動するので常にセット
$game_map.autoplay
end
moveto(@new_x, @new_y)
link_layer_followers
clear_transfer_info
end
end
#--------------------------------------------------------------------------
# ● マップイベントの起動
# triggers : トリガーの配列
# normal : プライオリティ［通常キャラと同じ］かそれ以外か
#--------------------------------------------------------------------------
def start_map_event(x, y, triggers, normal)
$game_map.events_xy(x, y).each do |event|
next unless check_enable_layer(event)
if event.trigger_in?(triggers) && event.normal_priority? == normal
event.start
end
end
end
#--------------------------------------------------------------------------
# ● 更新
#--------------------------------------------------------------------------
alias game_player_update update
def update
game_player_update
$game_system.layer = $game_player.active_layer
end
#--------------------------------------------------------------------------
# ● 乗り物に乗る
# 現在乗り物に乗っていないことが前提。
#--------------------------------------------------------------------------
def get_on_vehicle
add = 0
add =-1 if $game_map.get_chip_id(self.x, self.y, @active_layer) == Game_Map::LAYER_DW
add = 1 if $game_map.get_chip_id(self.x, self.y, @active_layer) == Game_Map::LAYER_UP
front_x = $game_map.x_with_direction(@x, @direction)
front_y = $game_map.y_with_direction(@y, @direction)
@vehicle_type = :boat if $game_map.boat.pos?(front_x, front_y) && @active_layer+add == $game_map.boat.active_layer # 正面に大型船がある？
@vehicle_type = :ship if $game_map.ship.pos?(front_x, front_y) && @active_layer+add == $game_map.ship.active_layer # 正面に小型船がある？
@vehicle_type = :airship if $game_map.airship.pos?(@x, @y)
if vehicle
@vehicle_getting_on = true
force_move_forward unless in_airship?
@followers.gather
end
link_layer_followers #フォロワーのレイヤーをリンク
@vehicle_getting_on
end
#--------------------------------------------------------------------------
# ● 乗り物から降りる
# 現在乗り物に乗っていることが前提。
#--------------------------------------------------------------------------
alias game_player_get_off_vehicle get_off_vehicle
def get_off_vehicle
front_x = $game_map.x_with_direction(@x, @direction)
front_y = $game_map.y_with_direction(@y, @direction)
id0 = $game_map.get_chip_id(front_x, front_y, @active_layer)
id1 = $game_map.get_chip_id(front_x, front_y, (@active_layer+1)%$game_map.get_layer_num)
return if id0 == Game_Map::LAYER_UP || id0 == Game_Map::LAYER_DW
return if id1 == Game_Map::LAYER_UP || id1 == Game_Map::LAYER_DW
link_layer_followers #フォロワーのレイヤーをリンク
game_player_get_off_vehicle
end
#--------------------------------------------------------------------------
# ● スクロール処理
#--------------------------------------------------------------------------
def update_scroll(last_real_x, last_real_y)
ax1 = $game_map.adjust_x(last_real_x, @active_layer)
ay1 = $game_map.adjust_y(last_real_y, @active_layer)
ax2 = $game_map.adjust_x(@real_x, @active_layer)
ay2 = $game_map.adjust_y(@real_y, @active_layer)
$game_map.scroll_down (ay2 - ay1) if ay2 > ay1 && ay2 > center_y
$game_map.scroll_left (ax1 - ax2) if ax2 < ax1 && ax2 < center_x
$game_map.scroll_right(ax2 - ax1) if ax2 > ax1 && ax2 > center_x
$game_map.scroll_up (ay1 - ay2) if ay2 < ay1 && ay2 < center_y
end
#--------------------------------------------------------------------------
# ● フォロワーのレイヤーをリンクする
#--------------------------------------------------------------------------
def link_layer_followers
@followers.each { |f| f.set_active_layer(@active_layer) }
end
end
#==============================================================================
# ■ Game_Vehicle
#------------------------------------------------------------------------------
# 　乗り物を扱うクラスです。このクラスは Game_Map クラスの内部で使用されます。
# 現在のマップに乗り物がないときは、マップ座標 (-1,-1) に設定されます。
#==============================================================================
class Game_Vehicle < Game_Character
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_reader :map_id
#--------------------------------------------------------------------------
# ● 座標一致判定
#--------------------------------------------------------------------------
def pos?(x, y)
#親のマップIDと同じか調べる＆同レイヤーか調べる＆同じ座標か調べる
$game_temp.link_array[@map_id][0] == $game_map.map_id && super(x, y)
end
#--------------------------------------------------------------------------
# ● 透明判定
#--------------------------------------------------------------------------
def transparent
#親のマップIDと同じか調べる
$game_temp.link_array[@map_id][0] != $game_map.map_id || super
end
#--------------------------------------------------------------------------
# ● オブジェクト初期化
# type : 乗り物タイプ（:boat, :ship, :airship）
#--------------------------------------------------------------------------
alias initialize_game_vehicle initialize
def initialize(type)
initialize_game_vehicle(type)
return if $BTEST
if $data_mapinfos[@map_id] != nil
temp_name = $data_mapinfos[@map_id].name
if temp_name.match(/\<lay(\d+)\>/)
set_active_layer($1.to_i)
else
set_active_layer(0)
end
end
end
#--------------------------------------------------------------------------
# ● リフレッシュ
#--------------------------------------------------------------------------
def refresh
if @driving
@map_id = $game_map.map_id
sync_with_player
elsif $game_temp.link_array[@map_id][0] == $game_map.map_id
#乗り物が存在するレイヤーなら位置とレイヤーをリセット
moveto(@x, @y)
end
if @type == :airship
@priority_type = @driving ? 2 : 0
else
@priority_type = 1
end
@walk_anime = @step_anime = @driving
end
#--------------------------------------------------------------------------
# ● 接岸／着陸可能判定
# d : 方向（2,4,6,8）
#--------------------------------------------------------------------------
def land_ok?(x, y, d)
if @type == :airship
return false unless $game_map.airship_land_ok?(x, y)
return false unless $game_map.events_xy(x, y).empty?
else
x2 = $game_map.round_x_with_direction(x, d)
y2 = $game_map.round_y_with_direction(y, d)
return false unless $game_map.valid?(x2, y2)
return false unless $game_map.passable?(x2, y2, reverse_dir(d), @active_layer)
return false if collide_with_characters?(x2, y2)
end
return true
end
#--------------------------------------------------------------------------
# ● 転送判定から除外できるか？
#--------------------------------------------------------------------------
def pre_hit?
return false if @active_layer > $game_map.get_layer_num-1
return true
end
end
#==============================================================================
# ■ Game_Character
#------------------------------------------------------------------------------
# 　主に移動ルートなどの処理を追加したキャラクターのクラスです。Game_Player、
# Game_Follower、GameVehicle、Game_Event のスーパークラスとして使用されます。
#==============================================================================
class Game_Character < Game_CharacterBase
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_reader :sprite_id
#--------------------------------------------------------------------------
# ● スプライトIDのセット
#--------------------------------------------------------------------------
def set_sprite_id(id)
@sprite_id = id
end
end
#==============================================================================
# ■ Game_Event
#------------------------------------------------------------------------------
# 　イベントを扱うクラスです。条件判定によるイベントページ切り替えや、並列処理
# イベント実行などの機能を持っており、Game_Map クラスの内部で使用されます。
#==============================================================================
class Game_Event < Game_Character
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :id
attr_reader :event
attr_reader :name
#--------------------------------------------------------------------------
# ● オブジェクト初期化
# event : RPG::Event
#--------------------------------------------------------------------------
def initialize(map_id, event)
super()
@map_id = map_id
@event = event
@id = @event.id
set_active_layer(@id / Game_Map::MAX_EVENT)
moveto(@event.x, @event.y)
refresh
end
#--------------------------------------------------------------------------
# ● 接触イベントの起動判定
#--------------------------------------------------------------------------
def check_event_trigger_touch(x, y)
return if $game_map.interpreter.running?
if @trigger == 2 && $game_player.pos?(x, y) && check_enable_layer($game_player)
start if !jumping? && normal_priority?
end
end
#--------------------------------------------------------------------------
# ● 画面の可視領域付近にいるか判定
# dx : 画面中央から左右何マス以内を判定するか
# dy : 画面中央から上下何マス以内を判定するか
#--------------------------------------------------------------------------
def near_the_screen?(dx = 12, dy = 8)
ax = $game_map.adjust_x(@real_x,@active_layer) - Graphics.width / 2 / 32
ay = $game_map.adjust_y(@real_y,@active_layer) - Graphics.height / 2 / 32
ax >= -dx && ax <= dx && ay >= -dy && ay <= dy
end
#--------------------------------------------------------------------------
# ● オブジェクトキャラクター判定
#--------------------------------------------------------------------------
def object_character?
if @event.name.index("接続イベント")
return 0
else
super
end
end
#--------------------------------------------------------------------------
# ● 転送判定から除外できるか？
#--------------------------------------------------------------------------
def pre_hit?
return false unless near_the_screen?
return false if $game_map.d_sprite(self).character == ""
return true
end
end
#==============================================================================
# ■ Game_CharacterBase
#------------------------------------------------------------------------------
# 　キャラクターを扱う基本のクラスです。全てのキャラクターに共通する、座標やグ
# ラフィックなどの基本的な情報を保持します。
#==============================================================================
class Game_CharacterBase
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_reader :active_layer
attr_reader :pattern
attr_accessor :tensou_rect_x
attr_accessor :tensou_rect_y
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias initialize2 initialize
def initialize
initialize2
@active_layer = 0
@tensou_rect_x = Rect.new
@tensou_rect_y = Rect.new
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
update_layer_change
update_animation
return update_jump if jumping?
return update_move if moving?
return update_stop
end
#--------------------------------------------------------------------------
# ● 所属レイヤーの変更
#--------------------------------------------------------------------------
def update_layer_change
return false if $game_map.get_layer_num == 1
return if @old_x == self.x && @old_y == self.y
id = $game_map.get_chip_id(self.x,self.y,@active_layer)
if id == Game_Map::LAYER_UP
@active_layer+=1
elsif id == Game_Map::LAYER_DW
@active_layer-=1
end
@old_x = self.x
@old_y = self.y
end
#--------------------------------------------------------------------------
# ● キャラクター衝突判定
# x : X 座標
# y : Y 座標
# プレイヤーと乗り物を含め、通常キャラの衝突を検出する。
#--------------------------------------------------------------------------
def collide_with_characters?(x, y)
#一歩前を見るのでこの形に
add = 0
check_layer = @active_layer
add = 1 if $game_map.get_chip_id(x, y, check_layer) == Game_Map::LAYER_UP
check_layer = @active_layer
add =-1 if $game_map.get_chip_id(x, y, check_layer) == Game_Map::LAYER_DW
collide_with_events?(x, y, add) || collide_with_vehicles?(x, y, add)
end
#--------------------------------------------------------------------------
# ● イベントとの衝突判定
#--------------------------------------------------------------------------
def collide_with_events?(x, y, add=0)
$game_map.events_xy_nt(x, y).any? do |event|
if event.active_layer == @active_layer || event.active_layer == @active_layer+add
event.normal_priority? || self.is_a?(Game_Event)
end
end
end
#--------------------------------------------------------------------------
# ● 乗り物との衝突判定
#--------------------------------------------------------------------------
def collide_with_vehicles?(x, y, add=0)
collide_with_boat?(x, y, add) || collide_with_ship?(x, y, add)
end
#--------------------------------------------------------------------------
# ● 大型船との衝突判定
#--------------------------------------------------------------------------
def collide_with_ship?(x, y, add=0)
if $game_map.ship.active_layer != @active_layer+add && $game_map.ship.active_layer != @active_layer
return false
end
$game_map.ship.pos_nt?(x, y)
end
#--------------------------------------------------------------------------
# ● 小型船との衝突判定
#--------------------------------------------------------------------------
def collide_with_boat?(x, y, add=0)
if $game_map.boat.active_layer != @active_layer+add && $game_map.boat.active_layer != @active_layer
return false
end
$game_map.boat.pos_nt?(x, y)
end
#--------------------------------------------------------------------------
# ● 位置設定(イベント位置設定用)
#--------------------------------------------------------------------------
def set_pos(new_x,new_y,dir=@direction,lay=@active_layer)
moveto(new_x, new_y)
set_active_layer(lay)
case dir # 向き
when 8 # 上
turn_up
when 6 # 右
turn_right
when 2 # 下
turn_down
when 4 # 左
turn_left
end
end
#--------------------------------------------------------------------------
# ● 茂み判定
#--------------------------------------------------------------------------
def bush?
$game_map.bush?(@x, @y, @active_layer)
end
#--------------------------------------------------------------------------
# ● 地形タグの取得
#--------------------------------------------------------------------------
def terrain_tag
$game_map.terrain_tag(@x, @y, @active_layer)
end
#--------------------------------------------------------------------------
# ● マップ通行可能判定
# x : X 座標
# y : Y 座標
#--------------------------------------------------------------------------
def map_passable?(x, y, d)
$game_map.passable?(x, y, d, @active_layer)
end
#--------------------------------------------------------------------------
# ● 違うレイヤーのイベント起動判定
#--------------------------------------------------------------------------
def check_enable_layer(object)
layer_num = $game_map.get_layer_num
id = $game_map.get_chip_id(self.x, self.y, (@active_layer+1)%layer_num)
if id == Game_Map::LAYER_DW
layer =(@active_layer+1) % $game_map.get_layer_num
return true if object.active_layer == @active_layer
return true if object.active_layer == @active_layer+1
end
id = $game_map.get_chip_id(self.x, self.y, (@active_layer-1)%layer_num)
if id == Game_Map::LAYER_UP
layer =(@active_layer-1) % $game_map.get_layer_num
return true if object.active_layer == @active_layer
return true if object.active_layer == @active_layer-1
end
#どちらでもない場合
return true if object.active_layer == @active_layer
return false
end
#--------------------------------------------------------------------------
# ● 画面 X 座標の取得
#--------------------------------------------------------------------------
def screen_x
$game_map.adjust_x(@real_x,@active_layer) * 32 + 16
end
#--------------------------------------------------------------------------
# ● 画面 Y 座標の取得
#--------------------------------------------------------------------------
def screen_y
$game_map.adjust_y(@real_y,@active_layer) * 32 + 32 - shift_y - jump_height
end
#--------------------------------------------------------------------------
# ● 所属レイヤーのセット
#--------------------------------------------------------------------------
def set_active_layer(no)
@active_layer = no
end
#--------------------------------------------------------------------------
# ● アニメパターンの更新
#--------------------------------------------------------------------------
def set_anime_pattern(pattern)
@pattern = pattern
end
end
#==============================================================================
# ■ Sprite_Character
#------------------------------------------------------------------------------
# 　キャラクター表示用のスプライトです。Game_Character クラスのインスタンスを
# 監視し、スプライトの状態を自動的に変化させます。
#==============================================================================
class Sprite_Character < Sprite_Base
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_reader :cw
attr_reader :ch
#--------------------------------------------------------------------------
# ● オブジェクト初期化
# viewport : ビューポート
# character : キャラクター (Game_Character)
#--------------------------------------------------------------------------
alias sprite_character_initialize initialize
def initialize(viewport, character = nil, layer = 0)
@layer = layer
@char_layer = character != nil ? character.active_layer : 0
sprite_character_initialize(viewport, character)
end
#--------------------------------------------------------------------------
# ● 指定されたタイルが含まれるタイルセット画像の取得
#--------------------------------------------------------------------------
def tileset_bitmap(tile_id)
Cache.tileset($game_map.tileset(@char_layer).tileset_names[5 + tile_id / 256])
end
#--------------------------------------------------------------------------
# ● フレーム更新を行うか？
#--------------------------------------------------------------------------
def update?
return false if SceneManager.scene.spriteset == nil
test_x = @character.x
test_y = @character.y
char_layer = @character.active_layer #キャラクターのレイヤー
id = $game_map.get_chip_id(test_x,test_y,[char_layer-1,0].max)
return false if id == Game_Map::LAYER_UP
id = $game_map.get_chip_id(test_x,test_y,[char_layer+1,$game_map.get_layer_num-1].min)
return false if id == Game_Map::LAYER_DW
return false if char_layer != @layer
return true
end
#--------------------------------------------------------------------------
# ● 幅と高さを調べるだけ
#--------------------------------------------------------------------------
def pre_set_character_bitmap
@tile_id = @character.tile_id
if @tile_id > 0
@cw = 32
@ch = 32
else
@character_name = @character.character_name
bitmap0 = Cache.character(@character_name)
sign = @character_name[/^[\!\$]./]
if sign && sign.include?('[/fold]
)
@cw = bitmap0.width / 3
@ch = bitmap0.height / 4
else
@cw = bitmap0.width / 12
@ch = bitmap0.height / 8
end
end
end
#--------------------------------------------------------------------------
# ● タイルのビットマップを設定
#--------------------------------------------------------------------------
alias sprite_character_set_tile_bitmap set_tile_bitmap
def set_tile_bitmap
sprite_character_set_tile_bitmap
@cw = 32
@ch = 32
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
return unless SceneManager.scene_is?(Scene_Map)
super
unless update?
self.visible = false
return
end
update_bitmap
update_src_rect
update_position
update_other
update_balloon
setup_new_effect
end
end
#==============================================================================
# ■ Sprite_Attach
#------------------------------------------------------------------------------
# 　接続イベント
#==============================================================================
class Sprite_Attach < Sprite_Base
#--------------------------------------------------------------------------
# ● オブジェクト初期化
# viewport : ビューポート
# character : キャラクター (Game_Character)
#--------------------------------------------------------------------------
def initialize(viewport, character = nil, layer = 0)
super(viewport)
@layer = layer
@char_layer = character != nil ? character.active_layer : 0
@character = character
@balloon_duration = 0
array = @character.event.name.scan(/接続イベント$(\d+),(\d+)$/)
w = array[0] != nil ? array[0][0].to_i : 160
h = array[0] != nil ? array[0][1].to_i : 96
self.bitmap = Bitmap.new(w,h)
@limit_x = w / 32
@limit_x += 1 if w % 32
@limit_y = h / 32
@limit_y += 1 if h % 32
end
#--------------------------------------------------------------------------
# ● 解放
#--------------------------------------------------------------------------
def dispose
super
end
#--------------------------------------------------------------------------
# ● フレーム更新を行うか？
#--------------------------------------------------------------------------
def update?
sprite_ctrl = SceneManager.scene.spriteset
return false if sprite_ctrl == nil
return false if sprite_ctrl.spriteset.size != $game_map.get_layer_num
return false if @character.active_layer != @layer
return true
end
#--------------------------------------------------------------------------
# ● 位置の更新
#--------------------------------------------------------------------------
def update_position
self.x = @character.screen_x
self.y = @character.screen_y
self.z = 101
end
#--------------------------------------------------------------------------
# ● 接続位置に本来表示されるべき絵を描く
# 自分の位置にはみだしている下のレイヤーのキャラの頭の部分を
# 自分のスプライトに転送する
#--------------------------------------------------------------------------
def update_s
self.bitmap.clear
self.ox = self.bitmap.width/2
self.oy = self.bitmap.height/2+16
$game_map.event_list.each {|ev| update_attach_bitmap(ev) if atari(ev)}
end
#--------------------------------------------------------------------------
# ● キャラクタースプライトがレイヤー移動チップと接触しているか？
#--------------------------------------------------------------------------
def hit_attach?(ev)
array_y = []
return false if d_sprite(ev) == nil
return false if sprite_w(ev) == nil || sprite_h(ev) == nil
#スプライトの大きさをチップ数に変換
chip_h = sprite_h(ev) / 32
chip_h += 1 if sprite_h(ev) % 32 > 0
while 1
chip_h -= 1
array_y.push(ev.y - chip_h)
break if chip_h == 0
end
ret = false
if ev.active_layer+1 == @character.active_layer
array_y.each do |y|
id = $game_map.get_chip_id(ev.x,y,@character.active_layer)
ret = true if id == Game_Map::LAYER_DW
end
elsif ev.active_layer-1 == @character.active_layer
array_y.each do |y|
id = $game_map.get_chip_id(ev.x,y,@character.active_layer)
ret = true if id == Game_Map::LAYER_UP
end
end
if ev.active_layer != @character.active_layer && ret == false
return false
end
return true
end
#--------------------------------------------------------------------------
# ● アタリ判定
#--------------------------------------------------------------------------
def atari(ev)
#接続イベントはチェックしない
return false if d_sprite(ev) == nil
#アップデートされない時の対処
if sprite_w(ev) == nil || sprite_h(ev) == nil
d_sprite(ev).pre_set_character_bitmap
end
#ある程度の所で足切り
sa_x = (@character.x.abs - ev.x.abs).abs
sa_y = (@character.y.abs - ev.y.abs).abs
return false if sa_x > @limit_x || sa_y > @limit_y
#キャラクタースプライトがレイヤー移動チップと接触しているか？
return false unless hit_attach?(ev)
c_x0 = @character.screen_x-self.bitmap.width/2 #左上
c_x1 = c_x0+self.bitmap.width
e_x0 = ev.screen_x-sprite_w(ev)/2
e_x1 = e_x0+sprite_w(ev)
c_y0 = @character.screen_y-self.bitmap.height/2-16 #左上
c_y1 = c_y0+self.bitmap.height
e_y0 = ev.screen_y-sprite_h(ev)
e_y1 = e_y0+sprite_h(ev)
#AのPがBのQより左上にあり、かつ、AのQがBのPより右下にある場合
if (c_x0 <= e_x1 && c_y0 <= e_y1) && (c_x1 >= e_x0 && c_y1 >= e_y0)
ev.tensou_rect_x.set(c_x0,c_x1,e_x0,e_x1)
ev.tensou_rect_y.set(c_y0,c_y1,e_y0,e_y1)
return true
end
return false
end
#--------------------------------------------------------------------------
# ● イベントに対応したスプライト
#--------------------------------------------------------------------------
def d_sprite(ev)
sprite_ctrl = SceneManager.scene.spriteset
return sprite_ctrl.spriteset[ev.active_layer].character_sprites[ev.sprite_id]
end
#--------------------------------------------------------------------------
# ● スプライトのwidthを取得
# bitmapの値を取らない！
#--------------------------------------------------------------------------
def sprite_w(ev)
d_sprite(ev)==nil ? nil : d_sprite(ev).cw
end
#--------------------------------------------------------------------------
# ● スプライトのwidthを取得
# bitmapの値を取らない！
#--------------------------------------------------------------------------
def sprite_h(ev)
d_sprite(ev)==nil ? nil : d_sprite(ev).ch
end
#--------------------------------------------------------------------------
# ● 自分のスプライトに転送する
#--------------------------------------------------------------------------
def update_attach_bitmap(ev)
src_bitmap = d_sprite(ev).bitmap #相手のビットマップ
@character_name = ev.character_name
@character_index = ev.character_index
@character_direction = ev.direction
@character_pattern = ev.pattern
#相手のビットマップと同じものを生成
@tile_id = ev.tile_id
if @tile_id > 0
#タイル
bitmap0 = tileset_bitmap(@tile_id)
@cw = 32
@ch = 32
sx = (@tile_id / 128 % 2 * 8 + @tile_id % 8) * 32;
sy = @tile_id % 256 / 8 % 16 * 32;
else
#キャラクター
bitmap0 = Cache.character(@character_name)
sign = @character_name[/^[\!\$]./]
if sign && sign.include?('[/fold]
)
@cw = bitmap0.width / 3
@ch = bitmap0.height / 4
else
@cw = bitmap0.width / 12
@ch = bitmap0.height / 8
end
index = @character_index
pattern = @character_pattern < 3 ? @character_pattern : 1
sx = (index % 4 * 3 + pattern) * @cw
sy = (index / 4 * 4 + (@character_direction - 2) / 2) * @ch
end
#重なっている部分の矩形
c_x0 = ev.tensou_rect_x.x
c_x1 = ev.tensou_rect_x.y
e_x0 = ev.tensou_rect_x.width
e_x1 = ev.tensou_rect_x.height
c_y0 = ev.tensou_rect_y.x
c_y1 = ev.tensou_rect_y.y
e_y0 = ev.tensou_rect_y.width
e_y1 = ev.tensou_rect_y.height
#はみ出している部分
k_w = 0
if e_x0 <= c_x0
k_w = e_x1 - c_x0
elsif e_x0 >= c_x0
k_w = c_x1 - e_x0
end
k_h = 0
if e_y0 <= c_y0
k_h = e_y1 - c_y0
elsif e_y0 >= c_y0
k_h = c_y1 - e_y0
end
#転送先の矩形
#転送先は必ず接続イベント
k_x = [e_x0-c_x0,c_x0-c_x0].max
k_y = [e_y0-c_y0,c_y0-c_y0].max
k_w = [k_w,sprite_w(ev)].min
k_h = [k_h,sprite_h(ev)].min
dest_rect = Rect.new(k_x,k_y,k_w,k_h)
t_x = 0
if c_x0 >= e_x0
t_x = sx + c_x0 - e_x0
elsif c_x0 <= e_x0
t_x = sx
end
t_y = 0
if c_y0 >= e_y0
t_y = sy + c_y0 - e_y0
elsif c_y0 <= e_y0
t_y = sy
end
return if k_w <= 0 || k_h <= 0
return if ev.transparent == true
src_rect = Rect.new(t_x,t_y,k_w,k_h)
self.bitmap.stretch_blt(dest_rect, bitmap0, src_rect)
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
def update
return unless SceneManager.scene_is?(Scene_Map)
super
unless update?
self.visible = false
return
else
self.visible = true
end
update_s
update_position
end
#--------------------------------------------------------------------------
# ● グラフィックの変更判定
#--------------------------------------------------------------------------
def graphic_changed?
@tile_id != @character.tile_id ||
@character_name != @character.character_name ||
@character_index != @character.character_index
end
#--------------------------------------------------------------------------
# ● 指定されたタイルが含まれるタイルセット画像の取得
#--------------------------------------------------------------------------
def tileset_bitmap(tile_id)
Cache.tileset($game_map.tileset.tileset_names[5 + tile_id / 256])
end
end
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、
# Game_Troop クラス、Game_Event クラスの内部で使用されます。
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# ● イベントのセットアップ
# list : 実行内容
# event_id : イベント ID
#--------------------------------------------------------------------------
alias Game_Interpreter_setup setup
def setup(list, event_id = 0)
Game_Interpreter_setup(list, event_id)
#どのレイヤーのイベントが起動したか
@setup_layer = event_id / Game_Map::MAX_EVENT
end
#--------------------------------------------------------------------------
# ● レイヤーの変更
#--------------------------------------------------------------------------
def set_active_layer(lay)
$game_map.events[@event_id].active_layer=lay if @event_id > 0
end
#--------------------------------------------------------------------------
# ● キャラクターの取得
# param : -1 ならプレイヤー、0 ならこのイベント、それ以外はイベント ID
#--------------------------------------------------------------------------
def get_character(param)
if $game_party.in_battle
nil
elsif param < 0
$game_player
else
events = same_map? ? $game_map.events : {}
add = @setup_layer * Game_Map::MAX_EVENT
events[param > 0 ? param+add : @event_id]
end
end
#--------------------------------------------------------------------------
# ● 指定位置の情報取得
#--------------------------------------------------------------------------
def command_285
if @params[2] == 0 # 直接指定
x = @params[3]
y = @params[4]
else # 変数で指定
x = $game_variables[@params[3]]
y = $game_variables[@params[4]]
end
case @params[1]
when 0 # 地形タグ
value = $game_map.terrain_tag(x, y, $game_map.events[@event_id].active_layer)
when 1 # イベント ID
value = $game_map.event_id_xy(x, y)
when 2..4 # タイル ID
value = $game_map.tile_id(x, y, @params[1] - 2)
else # リージョン ID
value = $game_map.region_id(x, y)
end
$game_variables[@params[0]] = value
end
end

复制代码

Vortur · 发表于 2016-2-16 17:11:14

本帖最后由 Vortur 于 2016-2-20 18:27 编辑

这个方法可能行：

1.找到脚本的最顶端class
2.在该class下加入判断

试试这样,以Scene_Base为例:
[pre lang="ruby"]  #--------------------------------------------------------------------------
  # ● 主逻辑
  #--------------------------------------------------------------------------
  def main
start
post_start
update until scene_changing?
pre_terminate
terminate
  end[/pre]
这段改为
[pre lang="ruby"]  #--------------------------------------------------------------------------
  # ● 主逻辑
  #--------------------------------------------------------------------------
  def main
if $66RPG==1
then
start
post_start
update until scene_changing?
pre_terminate
terminate
eng
  end[/pre]

当需要该功能时，就在事件里插入脚本
$66RPG=1，
否则
$66RPG=0

未测试，可能无效。猜测无效原因是：
该脚本于游戏进入时加载一遍，因编写的缘故，没有提供在游戏中刷新的功能；所以即使修改了变量，也无法被系统知道。

[已经过期] 语法问题，如何将一个代码块框起来？

加入我们，或者，欢迎回来。

点评

浏览过的版块

开拓者

短篇九导演组冠军