#==============================================================================#
# ¦ Mode 7 Script BETA for RMVX #
# |-> Author: Dusk Noun (24/1/09) #
# '-> Based on the original Script: 2chan (http://www.2ch.net/) #
#==============================================================================#
# ¦ Chronology #
# |-> Analyzed the original script by 2chan #
# |-> Edit useful methods and created the needed windows #
# '-> BETA release -> Made the mode 7 independent with 2 bugs #
#==============================================================================#
# ¦ Developing ideas #
# |-> Parallax on looped maps #
# |-> Angle settable #
# '-> Fix side-scrolling bitmap bug #
#==============================================================================#
# ¦ Notes of the author #
# - To avoid missunderstandings: I didn't create this script. I looked on the #
# script of the 2chan page (designed only for airships) and i made another #
# script based on it. So, I OWN this if they're credit as base script. I #
# haven't stolen anyone's idea. #
# - This is a BETA version. It's still developing so it shall have bugs #
#==============================================================================#
# ¦ Instructions #
# - Place it above main #
# - The best working is when you make a map both looped. If you do, you can't #
# put parallaxes. But it'll work best. You can do a non looped map but you #
# must respect a few patrons (read making non-looped maps) #
#==============================================================================#
# ¦ How to make a non-looped maps #
# - To make a non looped map, you must respect: #
# - Make the 2 1st files of the map transparent (the player can't go on them) #
# - Make a wall of transparent events to block the pass (optional) #
# - You need to put a parallax, if the map doesn't require it. Use the #
# in_black image on the pictures folder #
# IMPORTANT #
# - To leave it like that, the map must be looped horizontally #
# - If you don't won't to loop horizontally, you must make 2 event walls in #
# both borders to block the pass. And if you're gonna make a good view, #
# the parallaxe needs to have in perfect proportions, the front and side #
# walls. Use the Parallax patron image on Pictures folder to have a patron #
# NOTE: many of these things will be useless if the angle is changed. #
# NOTE: there can be some bugs in the parallax on vertically large and #
# non-looped maps. I'm trying to solve it. And there aren't 2 tiles. #
# There're more. With 50 tiles you need 1st 4 tiles transparent # #
#==============================================================================#
# ¦ Bugs #
# '-> In horizontal looped maps, tha player must walk a bit to make the floor #
# complete it's drawing #
#==============================================================================#
# ¦ Compatibility #
# - This script changes the spriteset_map class and makes other 2 classes. No #
# compatibility errors detected but they could be #
#==============================================================================#
module Game
DISPLAY_WIDTH = 544
DISPLAY_HEIGHT = 416
DISPLAY_CHIP_WIDTH = DISPLAY_WIDTH / 32
DISPLAY_CHIP_HEIGHT = DISPLAY_HEIGHT / 32
DISPLAY_REAL_WIDTH = DISPLAY_CHIP_WIDTH * 256
DISPLAY_REAL_HEIGHT = DISPLAY_CHIP_HEIGHT * 256
end
class Rect
def set_pos(x, y)
self.x = x
self.y = y
end
def set_size(w, h)
self.width = w
self.height = h
end
end
class TileBitmap < Bitmap
def initialize(width, height, tilemap)
super(width, height)
@tilemap = tilemap
@map_width = width / 32
@map_height = height / 32
@buffer = Bitmap.new(width, height)
@map_x = 999
@map_y = 999
@anime_face = 0
@anime_face_x = 0
@anime_speed = 30
@anime_count = @anime_speed
@main_autotile = MainAutotile.new(self, @tilemap.bitmaps)
@temprect = Rect.new(0,0,32,32)
@range = -1..1
end
def dispose
@buffer.dispose
@main_autotile.dispose
super
end
def set_tile(id, dx, dy)
case id
when 2048...2816
set_auto_tile1(id - 2048, dx, dy)
when 2816...4352
chipid, atid = (id -2816).divmod(48)
@main_autotile.draw(1,
atid, (chipid & 7) << 6 , (chipid >> 3) * 96, dx, dy, chipid)
when 4352...5888
set_auto_tile2(@tilemap.bitmaps[2], id - 4352, dx, dy)
when 5888...8000
set_auto_tile2(@tilemap.bitmaps[3], id - 5888, dx, dy)
when 1536...2048
set_normal_tile(@tilemap.bitmaps[4], id - 1536, dx, dy)
when 1...256
#0???????
set_normal_tile(@tilemap.bitmaps[5], id, dx, dy)
when 256...512
set_normal_tile(@tilemap.bitmaps[6], id - 256, dx, dy)
when 512...768
set_normal_tile(@tilemap.bitmaps[7], id - 512, dx, dy)
when 768...1536
set_normal_tile(@tilemap.bitmaps[8], id - 768, dx, dy)
end
end
def set_normal_tile(bitmap, id, dx, dy)
if(id < 128)
@temprect.set((id & 7) << 5, id >> 3 << 5, 32, 32)
else
id = id - 128
@temprect.set(((id & 7) + 8) << 5, id >> 3 << 5, 32, 32)
end
blt(dx, dy, bitmap, @temprect)
end
def set_auto_tile1(id, dx, dy)
chip_id, atid = id.divmod(48)
f = @anime_face
fx = @anime_face_x
case chip_id
when 0
@main_autotile.draw(0, atid, fx, 0, dx, dy, f)
when 1
@main_autotile.draw(0, atid, fx, 96, dx, dy, 8 + f)
when 2
@main_autotile.draw(0, atid, 192, 0, dx, dy, 3)
blt(dx, dy, @tilemap.bitmaps[0], Rect.new(192, 0, 32, 32))
when 3
blt(dx, dy, @tilemap.bitmaps[0], Rect.new(192, 96, 32, 32))
when 4
@main_autotile.draw(0, atid, 256 + fx, 0, dx, dy, f + 4)
when 6
@main_autotile.draw(0, atid, 256 + fx, 96, dx, dy, f + 12)
when 8
@main_autotile.draw(0, atid, fx, 192, dx, dy, f + 16)
when 10
@main_autotile.draw(0, atid, fx, 288, dx, dy, f + 20)
when 12
@main_autotile.draw(0, atid, 256 + fx, 192, dx, dy, f + 24)
when 14
@main_autotile.draw(0, atid, 256 + fx, 288, dx, dy, f + 28)
end
end
def anime_tile? (tile_id)
return tile_id && tile_id.between?(2048, 2815)
end
def set_auto_tile2(bitmap, id, dx, dy)
autotile_id = id % 48
real = id / 48
@temprect.set((real & 7) << 5, real >> 3 << 5, 32, 32)
blt(dx, dy, bitmap, @temprect)
end
def set_map(ox, oy)
return update_anime(ox, oy) if @map_x == ox && @map_y == oy
dir_x = ox - @map_x
dir_y = oy - @map_y
update_anime(ox - dir_x, oy - dir_y)
if @range === dir_x && @range === dir_y
case
when dir_x.zero? && dir_y == -1
copy_from_buffer(Rect.new(0, 0, width, height - 32), 0, 32)
draw_map(0, 0, ox, oy,
ox + @map_width, oy + 1)
when dir_x.zero? && dir_y == 1
copy_from_buffer(Rect.new(0, 32, width, height - 32), 0, 0)
draw_map(0, height - 32, ox, oy + @map_height - 1,
ox + @map_width, oy + @map_height)
when dir_y.zero? && dir_x == -1
copy_from_buffer(Rect.new(0, 0, width - 32, height), 32, 0)
draw_map(0, 0, ox, oy,
ox + 1, oy + @map_height)
when dir_y.zero? && dir_x == 1
copy_from_buffer(Rect.new(32, 0, width - 32, height), 0, 0)
draw_map(width - 32, 0, ox + @map_width - 1, oy,
ox + @map_width, oy + @map_height)
end
else
clear
draw_map(0, 0, ox, oy, ox + @map_width, oy + @map_height)
end
@map_x = ox
@map_y = oy
return true
end
def next_anime_face
@anime_face = (@anime_face + 1) % 3
@anime_face_x = @anime_face << 6
end
def update_anime(ox, oy)
if @anime_count.zero?
next_anime_face
x = y = dx = dy = 0
data = $game_map.data
map_each(ox+3, oy, ox + @map_width-3, oy + @map_height) do |x, y, dx, dy|
if anime_tile?(data[x, y, 0])
for z in 0..2
tile_id = data[x, y, z]
set_tile(tile_id, 96 + dx, dy) if tile_id
end
end
end
@anime_count = @anime_speed
return true
else
@anime_count -= 1
return false
end
end
def copy_from_buffer(r, bx, by)
@buffer.clear
@buffer.blt(0, 0, self, self.rect)
clear
blt(bx, by, @buffer, r)
end
def draw_map(tox, toy, ox, oy, xmax, ymax)
data = $game_map.data
x = y = dx = dy = 0
map_each(ox, oy, xmax, ymax) do |x, y, dx, dy|
for z in 0..2
tile_id = data[x, y, z]
set_tile(tile_id, tox + dx, toy + dy) if tile_id
end
end
end
def map_each(sx, sy, ex, ey)
mapw = $game_map.width
maph = $game_map.height
isv = $game_map.loop_vertical?
ish = $game_map.loop_horizontal?
draw_y = 0
for y in sy...ey
y = get_looped_point(y, maph) if isv
draw_x = 0
for x in sx...ex
x = get_looped_point(x, mapw) if ish
yield(x, y, draw_x, draw_y)
draw_x += 32
end
draw_y += 32
end
end
def get_looped_point(val, size)
return case
when size <= val then val -= size
when val < 0 then val += size
else val
end
end
end
class TileSprite < Sprite
def initialize(width, height, tilemap, viewport)
super(viewport)
self.bitmap = Bitmap.new(Game::DISPLAY_WIDTH, Game::DISPLAY_HEIGHT)
self.x = 0
self.y = 0
self.ox = 0
self.oy = 0
self.z = 0
@backbuffer = TileBitmap.new(width, height, tilemap)
@bg = Sprite.new(viewport)
@bg.z = 1
@bg.blend_type = 1
@bg.bitmap = Cache.picture('m7')
@mapx = -999
@mapy = -999
@x_plus = (width - Game::DISPLAY_WIDTH) / 2
@y_plus = 128
@draw_count = false
@x_table = Table.new(416)
@y_table = Table.new(416)
set_render_table(45)
end
def dispose
@bg.dispose if @bg
@backbuffer.dispose if @backbuffer
self.bitmap.dispose if self.bitmap
super
end
def hide
self.visible = false
@bg.visible = false
end
def show
self.visible = true
@bg.visible = true
end
def set_render_table(angle)
return false if angle == @angle
@angle = angle
d = 1000.0
rad = angle * Math::PI / 180
sina = Math.sin(rad)
cosa = Math.cos(rad)
x_zoom = 544 * 0.8
for i in 0...416
sy = 208 - i
unless angle == 6
aaa = sy == 0 ? 0: (90 - angle) / 208.0 * sy
aaa = sy < 0 ? 90 + aaa : 90 - aaa
rad = aaa * Math::PI / 180
sy = (sy / Math.sin(rad)) * (d + (sy * Math.cos(rad))) / d
end
to_y = sina.zero? ? -256: ((sy / sina) * (d + (sy * cosa)) / d).round
@y_table[i] = 208 - to_y
to_x = (-x_zoom * (d + (sy * -cosa)) / d) + x_zoom
@x_table[i] = - (272 * to_x / (272 - to_x )).round#(272 * to_x / (272 - to_x )).round ##########################
end
case @angle
when 45
@bg.zoom_y = 1.0
when 90
@bg.zoom_y = 0.0
else
@bg.zoom_y = (1.0 / 45) * (90 - @angle)
end
@bg.opacity = 255 * @bg.zoom_y
return true
end
def update_map(ox, oy)
return unless self.visible
aox = ($game_map.display_x >> 3 & 31) + @x_plus
aoy = ($game_map.display_y >> 3 & 31) + @y_plus
ud = set_render_table($game_map.get_angle)
sd = @backbuffer.set_map(ox, oy)
return if !sd && !ud && aox == @mapx && aoy == @mapy
update_bitmap(aox, aoy)
end
def update_bitmap(aox, aoy)
@mapx = aox
@mapy = aoy
unless aox == @x_plus && aoy == @y_plus
@draw_count = !@draw_count
return if @draw_count
end
bmp = self.bitmap
bmp.clear
bmph = bmp.height
bmpw = bmp.width
yt = @y_table
xt = @x_table
bb = @backbuffer
from_r = Rect.new(0, 0, 1 , 1)
to_r = Rect.new(0, 0, bmpw, 1)
i = 0
while i < bmph
to_y = yt[i]
if to_y < -@y_plus
i += 1
next
end
to_x = xt[i]
to_r.y = i
ww = 0
while i < bmph
ww += 1
i += 1
break unless to_x == xt[i] && to_y + ww == yt[i]
end
to_r.height = ww
from_r.set(to_x + aox, to_y + aoy, bmpw - to_x - to_x, ww)
bmp.stretch_blt(to_r, bb, from_r)
end
end
end
class Game_Map
attr_accessor :mode3D
alias a9_003_initialize initialize
def initialize
a9_003_initialize
@mode3D = true
@angle3D = 60 #60
end
def set_angle(v)
@angle3D = v
end
def get_angle
@angle3D
end
end
class Spriteset_Map
alias a9_003_create_viewports create_viewports
def create_viewports
a9_003_create_viewports
@viewport_invisible = Viewport.new(0, 0, 1, 1)
@viewport_invisible.visible = false
end
alias a9_003_dispose_viewports dispose_viewports
def dispose_viewports
a9_003_dispose_viewports
@viewport_invisible.dispose
end
alias a9_003_create_tilemap create_tilemap
def create_tilemap
a9_003_create_tilemap
@tilemap.visible = false
@tile_sprite = TileSprite.new(544+448, 480+128, @tilemap, @viewport1)#(544+448, 416+128, @tilemap, @viewport1)
end
def begin_3d
@tilemap.viewport = @viewport_invisible
@mode3d = true
@tile_sprite.show
end
alias a9_003_dispose_tilemap dispose_tilemap
def dispose_tilemap
a9_003_dispose_tilemap
@tile_sprite.dispose
end
alias a9_003update_tilemap update_tilemap
def update_tilemap
g = $game_map
unless g.mode3D == @mode3d
@mode3d ? end_3d: begin_3d
end
unless @mode3d
a9_003update_tilemap
else
@tile_sprite.update_map((g.display_x >> 8) - 7, (g.display_y >> 8) - 4)
end
end
end
class Game_Vehicle < Game_Character
#--------------------------------------------------------------------------
# ? Not sure if it's removable
#--------------------------------------------------------------------------
alias a9_003_update update
def update
a = @altitude
a9_003_update
update_angle(a)
end
def update_angle(alti)
def set_angle
$game_map.set_angle(90 - (45 / 8 * (@altitude / 4 + 1)))
end
end
end
#-------------------------------------------------------------------------
class MainAutotile
def initialize(parent, tilebitmaps)
super()
@parent = parent
@bitmaps = tilebitmaps
@rect = Rect.new(0, 0, 16, 16)
@lt_buffer = {0=>1, 4=>1, 6=>1, 8=>1, 12=>1, 19=>1, 23=>1, 32=>1, 33=>1}
@lt_buf_0 = {0=>1, 4=>1, 6=>1, 8=>1, 12=>1}
@lt_buf_1 = {19=>1, 32=>1}
@lt_buf_2 = {23=>1,33=>1}
@lt_1 = {1=>1, 3=>1, 5=>1, 7=>1, 9=>1, 11=>1, 13=>1,
15=>1, 26=>1, 27=>1, 29=>1, 31=>1, 39=>1}
@lt_2 = {34=>1, 35=>1, 42=>1, 43=>1, 46=>1 }
@lt_3 = {20=>1, 21=>1, 22=>1, 36=>1, 37=>1, 45=>1}#23, 33
@lt_4 = {16=>1, 17=>1, 18=>1, 40=>1, 41=>1, 44=>1}#17..19, 32
@lt_5 = {2=>1, 4=>1, 8=>1, 10=>1, 14=>1, 24=>1,
25=>1, 28=>1, 30=>1, 38=>1}#0, 6, 12
@rt_buffer = {27=>1}
@rt_height = {6=>1, 14=>1, 20=>1, 22=>1, 27=>1, 28=>1, 29=>1}#7
@lb_buffer = {1=>1, 2=>1, 3=>1, 31=>1}
@lb_width = {1=>1, 2=>1, 3=>1, 12=>1, 14=>1, 16=>1, 17=>1, 26=>1, 31=>1}
make_buffer
end
def draw(bmpNo, atid, ox, oy, dx, dy, bufid)
r = @rect
r.set_size(16, 16)
b = @parent
bw = bufid << 5
bmps = rect = nil
return if draw_lt(r, atid, ox, oy, bw) do |bmps, rect|
b.blt(dx, dy, bmps[bmpNo], rect)
end
draw_rt(r, atid, ox, oy, bw) do |bmps, rect|
b.blt(dx + 16, dy, bmps[bmpNo], rect)
end
return if draw_lb(r, atid, ox, oy, bw) do |bmps, rect|
b.blt(dx, dy + 16, bmps[bmpNo], rect)
end
draw_rb(r, atid, ox, oy) do |bmps, rect|
b.blt(dx + 16, dy + 16, bmps[bmpNo], rect)
end
end
def dispose
@buffers.each do |v|
v.dispose
end
end
private
def make_buffer
@buffers = []
bmp1 = Bitmap.new(1024, 96)
@buffers[0] = bmp1
tobmp = @bitmaps[0]
for i in 0..6
draw_buffer(tobmp, i * 64, 0, bmp1, i * 32, 0)
end
for i in 0..6
draw_buffer(tobmp, i * 64, 96, bmp1, 256 + (i * 32), 0)
end
for i in [0, 1, 2, 4, 5, 6]
draw_buffer(tobmp, i * 64, 192, bmp1, 512 + (i * 32), 0)
end
for i in [0, 1, 2, 4, 5, 6]
draw_buffer(tobmp, i * 64, 288, bmp1, 768 + (i * 32), 0)
end
bmp2 = Bitmap.new(1024, 96)
@buffers[1] = bmp2
tobmp = @bitmaps[1]
for i in 0..7
draw_buffer(tobmp, i * 64, 0, bmp2, i * 32, 0)
end
for i in 0..7
draw_buffer(tobmp, i * 64, 96, bmp2, 256 + (i * 32), 0)
end
for i in 0..7
draw_buffer(tobmp, i * 64, 192, bmp2, 512 + (i * 32), 0)
end
for i in 0..7
draw_buffer(tobmp, i * 64, 288, bmp2, 768 + (i * 32), 0)
end
end
def draw_buffer(bmp, ox, oy, tobmp, tox, toy)
r = Rect.new(0, 0, 16, 16)
r.set_pos(ox + 32, oy + 64)
tobmp.blt(tox, toy, bmp, r)
r.set_pos(ox + 16, oy + 64)
tobmp.blt(tox + 16, toy, bmp, r)
r.set_pos(ox + 32, oy + 48)
tobmp.blt(tox, toy + 16, bmp, r)
r.set_pos(ox + 16, oy + 48)
tobmp.blt(tox + 16, toy + 16, bmp, r)
r.set_pos(ox, oy + 64)
tobmp.blt(tox, toy + 32, bmp, r)
r.set_pos(ox + 48, oy + 64)
tobmp.blt(tox + 16, toy + 32, bmp, r)
r.set_pos(ox, oy + 48)
tobmp.blt(tox, toy + 48, bmp, r)
r.set_pos(ox + 48, oy + 48)
tobmp.blt(tox + 16, toy + 48, bmp, r)
r.set_pos(ox + 32, oy + 32)
tobmp.blt(tox, toy + 64, bmp, r)
r.set_pos(ox + 16, oy + 32)
tobmp.blt(tox + 16, toy + 64, bmp, r)
r.set_pos(ox + 32, oy + 80)
tobmp.blt(tox, toy + 80, bmp, r)
r.set_pos(ox + 16, oy + 80)
tobmp.blt(tox + 16, toy + 80, bmp, r)
end
def draw_lt(r, atid, ox, oy, bx)
case
when @lt_buf_0.key?(atid)
r.x = bx
r.y = 0
when @lt_buf_1.key?(atid)
r.x = bx
r.y = 32
when @lt_buf_2.key?(atid)
r.x = bx
r.y = 64
when @lt_1.key?(atid)
r.x = ox + 32
r.y = oy
when @lt_2.key?(atid)
r.x = ox
r.y = oy + 32
when @lt_3.key?(atid)
r.x = ox + 32
r.y = oy + 32
when @lt_4.key?(atid)
r.x = ox
r.y = oy + 64
when @lt_5.key?(atid)
r.x = ox + 32
r.y = oy + 64
end
bool = false
case atid
when 0, 15, 32..34, 36, 38, 40
r.set(r.x, r.y, 32, 32)
bool = true
when 3, 4, 7, 8, 11, 12, 16, 18, 23, 25, 35, 37
r.width = 32
when 6, 9, 13, 19, 20, 28, 41
r.height = 32
end
yield(@lt_buffer.key?(atid) ? @buffers : @bitmaps , r)
return bool
end
def draw_rt(r, atid, ox, oy, bx)
if case atid
when 27
r.set_pos(bx + 16, 32)
when 2, 6, 10, 14, 15, 17, 19, 30, 31, 41 #2, 3, 7, 11
r.set_pos(ox + 48, oy)
when 1, 5, 9, 13, 28, 29, 40 #0, 1, 4, 8, 12, 16, 18
r.set_pos(ox + 16, oy + 64)
when 20..22, 34, 43 #35, 33, 23
r.set_pos(ox + 16, oy + 32)
when 24, 26, 38, 39, 44 #25, 27, 32
r.set_pos(ox + 48, oy + 64)
when 36, 42, 45, 46 #37
r.set_pos(ox + 48, oy + 32)
end then
r.set(r.x, r.y, 16, @rt_height.key?(atid) ? 32: 16)
yield(@rt_buffer.key?(atid) ? @buffers : @bitmaps, r)
end
return false
end
def draw_lb(r, atid, ox, oy, bx)
if case atid
when 1, 2, 3
r.set_pos(bx, 16)
when 31
r.set_pos(bx, 80)
when 8, 10, 11, 12, 14, 15, 22, 23, 25, 27, 37 #9, 13
r.set_pos(ox + 32, oy + 16)
when 4, 5, 7, 21, 24, 26, 36 #0, 1,2,3, 6, 20
r.set_pos(ox + 32, oy + 48)
when 16, 17, 18, 32, 34, 35, 42 #19
r.set_pos(ox, oy + 48)
when 29, 30, 38, 39, 45 #28, 33, 31
r.set_pos(ox + 32, oy + 80)
when 40, 43, 44, 46 #41
r.set_pos(ox, oy + 80)
end then
is_buf = @lb_width.key?(atid)
r.set(r.x, r.y, is_buf ? 32: 16, 16)
yield(@lb_buffer.key?(atid) ? @buffers : @bitmaps, r)
return is_buf || @rt_height.key?(atid)
end
return false
end
def draw_rb(r, atid, ox, oy)
case atid
when 4, 5, 7, 13, 15, 18, 19, 21, 23, 35 #6, 12, 14
r.set_pos(ox + 48, oy + 16)
when 8..11, 16, 34 #0,1,2,3, 17, 20, 22
r.set_pos(ox + 16, oy + 48)
when 24, 25, 27, 32, 36, 37, 42 #26
r.set_pos(ox + 48, oy + 48)
when 30, 40, 41, 43 #28, 29, 31, 33
r.set_pos(ox + 16, oy + 80)
when 38, 39, 44..46
r.set_pos(ox + 48, oy + 80)
else return
end
yield (@bitmaps, r)
end
end
class Window_unview < Window_Base
def initialize (x = 0, y = 0, width = 544, height = 73)
super
self.z = 255
self.back_opacity = 0
self.opacity = 0
var_calc
create_wall
end
def var_calc
if $game_map.parallax_name == ""
@parallax = Cache.picture('fader')
@z = 300
else
@parallax = Cache.parallax($game_map.parallax_name)
@z = 0
end
end
def draw_parallax
@wall = Sprite.new
@wall.bitmap = @parallax
@wall.x = 0
@wall.y = 0
@wall.z = @z
end
def create_wall
self.contents.clear
draw_parallax
end
end
class Scene_Map
alias befm7_start start
def start
befm7_start
Window_unview.new
end
end
Kandidat 1
Kandidat 2
Kandidat 3
Kandidat 4
Kandidat 5