+- Ultima Forum (https://forum.ultimateam.pl)
+-- Dział: RPG Maker (/Forum-RPG-Maker)
+--- Dział: Skrypty (/Forum-Skrypty)
+---- Dział: RGSS3 (/Forum-RGSS3)
+---- Wątek: [VX / VXAce] Podmiana tilesetów (/Thread-VX-VXAce-Podmiana-tileset%C3%B3w)
Podmiana tilesetów - Angius - 11-05-13 15:03
Krótki opis:
Skrypt umożliwia podmianę tilesetów na inne, np. czystej wody na brudną, czy litej ściany na pękniętą.
Autor:
Tsukihime
Skrypt:
Spoiler: (Otwórz)
Kod:
=begin
================================================================================
** Tile Swap
Author: Tsukihime
Date: May 5, 2013
--------------------------------------------------------------------------------
** Change log
2.3 May 5
-fixed bug where A5 tiles were not being swapped properly. This is because
they were treated as auto-tiles instead of normal tiles
2.2 May 4
-updated to support overlay maps
2.1 Apr 11
-fixed bug where B-E pages weren't handled properly
2.0 Feb 17
-removed use of a new map. Should be more compatible now
-fixed bug where last row of page A4 tiles were skipped
-revised input format
-proper autotile swapping
1.2 Jan 22, 2013
-fixed bug where swap by position didn't handle layers properly
1.1 May 20
-Added support for reverting tiles
1.0 May 16, 2012
-Initial release
--------------------------------------------------------------------------------
** Terms of Use
* Free to use in commercial/non-commercial projects
* The script is provided as-is
* Cannot guarantee that it is compatible with other scripts
* Preserve this header
--------------------------------------------------------------------------------
** Description
This script allows you to change the tiles on a map, and also revert the
changes.
--------------------------------------------------------------------------------
** Compatibility
Let me know.
--------------------------------------------------------------------------------
** Usage
Please refer to the reference section to understand what a tileID is and
how these script calls should be made.
There are three types of tile swaps
1. Change by tile id
-All tiles on the map with the specified ID will be changed to a new tile
Usage: tile_swap(old_tileID, new_tileID, layer, map_id)
2. Change by region id
-All tiles that are covered by the specified region ID will be changed
to a new tile
Usage: region_swap(regionID, tileID, layer, map_id)
3. Change by position
-The tile at the specified position will be changed to a new tile
Usage: pos_swap(x, y, tileID, layer, map_id)
You can undo tile swaps using analogous functions
tile_revert(tid, layer, map_id)
pos_revert(x, y, tid, layer, map_id)
region_revert(rid, layer, map_id)
revert_all(map_id)
--------------------------------------------------------------------------------
** Reference
This script uses the concept of a "tile ID", which is a special string
that represents a particular tile on your tileset.
The format of this tile ID is a letter, followed by a number.
The letters available are based on the tileset names
A, B, C, D, E
The number represents the ID of the tile.
So for example, "A1" would be the the first tile in tileset A, whereas
"B12" would be the 12th tile of tileset B.
To determine the ID of a tile, it is easy: simply look at your tileset and
number the top-left tile as 1. Then, number them from left-to-right,
top-to-bottom as such
1 2 3 4 5 6 7 8
9 10 11 12 13 14 15 16
...
The ID that you want is exactly as it appears on your tileset.
--------------------------------------------------------------------------------
** Credits
KilloZapit, for the excellent auto-tile generation code
================================================================================
=end
$imported = {} if $imported.nil?
$imported["TH_TileSwap"] = true
#===============================================================================
# ** Rest of the script.
#===============================================================================
module TH
module Tile_Swap
Tileset_Map = {
"A" => 0,
"B" => 1,
"C" => 2,
"D" => 3,
"E" => 4,
}
ID_Keys = [128, 80, 48, 16, 0]
ID_Table = {
0 => [48, 2048],
16 => [48, 2816],
48 => [48, 4352],
80 => [48, 5888],
128 => [1, 1536]
}
end
end
class Game_System
include TH::Tile_Swap
#-----------------------------------------------------------------------------
# New. Convert my tileID to an internal tile ID.
#-----------------------------------------------------------------------------
def convert_tid(tileID)
page = tileID[0].upcase
tid = tileID[1..-1].to_i - 1
page = Tileset_Map[page]
if page == 0
ID_Keys.each {|key|
p (tid - key) * ID_Table[key][0] + ID_Table[key][1] if tid >= key
return (tid - key) * ID_Table[key][0] + ID_Table[key][1] if tid >= key
}
else
# pages B, C, D, and E all have 256 icons per page.
tid + (256 * (page - 1))
end
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def initialize_tile_list(map_id, layer)
@swapped_tiles = {} if @swapped_tiles.nil?
@swapped_tiles[map_id] = {} if @swapped_tiles[map_id].nil?
@swapped_tiles[map_id][layer] = {} if @swapped_tiles[map_id][layer].nil?
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def initialize_pos_list(map_id, layer)
@swapped_pos_tiles = {} if @swapped_pos_tiles.nil?
@swapped_pos_tiles[map_id] = {} if @swapped_pos_tiles[map_id].nil?
@swapped_pos_tiles[map_id][layer] = {} if @swapped_pos_tiles[map_id][layer].nil?
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def initialize_region_list(map_id)
@swapped_region_tiles = {} if @swapped_region_tiles.nil?
@swapped_region_tiles[map_id] = {} if @swapped_region_tiles[map_id].nil?
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def has_swap_tiles?(map_id, layer)
return false if @swapped_tiles.nil?
return false if @swapped_tiles[map_id].nil? || @swapped_tiles[map_id].empty?
return false if @swapped_tiles[map_id][layer].nil? || @swapped_tiles[map_id][layer].empty?
return true
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def has_swap_pos?(map_id, layer)
return false if @swapped_pos_tiles.nil?
return false if @swapped_pos_tiles[map_id].nil? || @swapped_pos_tiles[map_id].empty?
return false if @swapped_pos_tiles[map_id][layer].nil? || @swapped_pos_tiles[map_id][layer].empty?
return true
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def has_swap_region?(map_id, layer)
return false if @swapped_region_tiles.nil?
return false if @swapped_region_tiles[map_id].nil? || @swapped_region_tiles[map_id].empty?
return true
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def swapped_tiles(map_id, layer, tid)
initialize_tile_list(map_id, layer)
@swapped_tiles[map_id][layer][tid]
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def swapped_positions(map_id, layer)
initialize_pos_list(map_id, layer)
@swapped_pos_tiles[map_id][layer]
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def swapped_regions(map_id, rid, layer)
initialize_region_list(map_id)
@swapped_region_tiles[map_id][[rid, layer]]
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def add_tile_id(map_id, layer, old_tid, new_tid)
initialize_tile_list(map_id, layer)
old_tid = convert_tid(old_tid)
new_tid = convert_tid(new_tid)
@swapped_tiles[map_id][layer][old_tid] = new_tid
$game_map.load_new_map_data
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def add_region_tile(map_id, rid, layer, tid)
initialize_region_list(map_id)
tid = convert_tid(tid)
@swapped_region_tiles[map_id][[rid, layer]] = tid
$game_map.load_new_map_data
end
#-----------------------------------------------------------------------------
# New.
#-----------------------------------------------------------------------------
def add_position_tile(map_id, x, y, layer, tid)
initialize_pos_list(map_id, layer)
tid = convert_tid(tid)
@swapped_pos_tiles[map_id][layer][[x, y]] = tid
$game_map.load_new_map_data
end
#-----------------------------------------------------------------------------
# New. Remove all custom tiles on the map for a given layer and tileID
#-----------------------------------------------------------------------------
def revert_tile(map_id, layer, tid)
initialize_tile_list(map_id, layer)
tid = convert_tid(tid)
@swapped_tiles[map_id][layer].delete(tid)
$game_map.reload_map
end
#-----------------------------------------------------------------------------
# New. Remove all custom tiles on the map for a given layer and position
#-----------------------------------------------------------------------------
def revert_pos(map_id, x, y, layer)
initialize_pos_list(map_id, layer)
@swapped_pos_tiles[map_id][layer].delete([x, y])
$game_map.reload_map
end
#-----------------------------------------------------------------------------
# New. Remove all custom tiles on the map for a given layer and region
#-----------------------------------------------------------------------------
def revert_region(map_id, layer, rid)
initialize_region_list(map_id)
@swapped_region_tiles[map_id].delete([rid, layer])
$game_map.reload_map
end
#-----------------------------------------------------------------------------
# New. Remove all custom tiles from the given map
#-----------------------------------------------------------------------------
def revert_all(map_id)
@swapped_tiles = {} if @swapped_tiles.nil?
@swapped_pos_tiles = {} if @swapped_pos_tiles.nil?
@swapped_region_tiles = {} if @swapped_region_tiles.nil?
@swapped_tiles[map_id] = {}
@swapped_pos_tiles[map_id] = {}
@swapped_region_tiles[map_id] = {}
$game_map.reload_map
end
end
class Game_Map
#-----------------------------------------------------------------------------
# Aliased. Load new map data after the original map is loaded
#-----------------------------------------------------------------------------
alias :tsuki_tile_swap_setup_map :setup
def setup(map_id)
tsuki_tile_swap_setup_map(map_id)
load_new_map_data
end
#-----------------------------------------------------------------------------
# New. Grab the original map data and load that up
#-----------------------------------------------------------------------------
def reload_map
new_map = load_data(sprintf("Data/Map%03d.rvdata2", @map_id))
@map.data = new_map.data
load_new_map_data
end
#-----------------------------------------------------------------------------
# New. Load custom map data on top of our map
#-----------------------------------------------------------------------------
def load_new_map_data
@updated_tiles = {}
swap_tile_id
swap_tile_region
swap_tile_pos
expand_updated_tiles
update_all_autotiles
end
#-----------------------------------------------------------------------------
# New. Swap tiles by tile ID
#-----------------------------------------------------------------------------
def swap_tile_id
for z in 0...3
next unless $game_system.has_swap_tiles?(@map_id, z)
for x in 0...@map.width
for y in 0...@map.height
old_tid = floor_autotile_id(@map.data[x, y, z])
new_tile = $game_system.swapped_tiles(@map_id, z, old_tid)
if new_tile
@map.data[x, y, z] = new_tile
@updated_tiles[[x,y]] = 1
end
end
end
end
end
#-----------------------------------------------------------------------------
# New. Swap tiles by region
#-----------------------------------------------------------------------------
def swap_tile_region
for z in 0...3
next unless $game_system.has_swap_region?(@map_id, z)
for x in 0...@map.width
for y in 0...@map.height
rid = region_id(x, y)
new_tile = $game_system.swapped_regions(@map_id, rid, z)
if new_tile
@map.data[x, y, z] = new_tile
@updated_tiles[[x,y]] = 1
end
end
end
end
end
#-----------------------------------------------------------------------------
# New. Swap tiles by position
#-----------------------------------------------------------------------------
def swap_tile_pos
for z in 0 ... 3
new_tiles = $game_system.swapped_positions(@map_id, z)
if new_tiles
for new_tile in new_tiles
@map.data[new_tile[0][0], new_tile[0][1], z] = new_tile[1]
@updated_tiles[new_tile[0]] = 1
end
end
end
end
#-----------------------------------------------------------------------------
# New. If it is an auto-tile ID, get the base autotile ID
# (without considering autotile index)
#-----------------------------------------------------------------------------
def floor_autotile_id(id)
return (id >= 2048) ? id - ((id - 2048) % 48) : id
end
#-----------------------------------------------------------------------------
# New. In addition to the updated tile, we must update all adjacent tiles
# as well
#-----------------------------------------------------------------------------
def expand_updated_tiles
new_tiles = {}
@updated_tiles.each {|(x,y), val|
new_tiles[[x,y]] = 1,
new_tiles[[x+1, y]] = 1,
new_tiles[[x-1, y]] = 1,
new_tiles[[x, y+1]] = 1,
new_tiles[[x, y-1]] = 1,
new_tiles[[x+1, y-1]] = 1,
new_tiles[[x+1, y+1]] = 1,
new_tiles[[x-1, y-1]] = 1,
new_tiles[[x-1, y+1]] = 1
}
@updated_tiles = new_tiles
end
#-----------------------------------------------------------------------------
# The following contains auto-tile generation code by KilloZapit
#-----------------------------------------------------------------------------
def autotile_edge(autotile, x, y, z)
# Special dungeon logic
# makes overlay grass tiles "grow" out of walls.
valid?(x, y) && autotile != autotile_type(x, y, z)
end
def autotile_wall_edge(autotile, x, y, z)
if (autotile / 8) % 2 == 1
return false if autotile_type(x, y, z) + 8 == autotile
end
autotile_edge(autotile, x, y, z)
end
def update_all_autotiles
@updated_tiles.each {|(x, y), val|
update_autotile(x, y, 0)
update_autotile(x, y, 1)
}
end
def update_autotile(x, y, z)
autotile = autotile_type(x, y, z)
return if autotile < 0
index = 0
case get_autotile_group(autotile)
when 2
l = autotile_edge(autotile, x - 1, y, z)
r = autotile_edge(autotile, x + 1, y, z)
index = waterfall_autotile_index(l,r)
when 1
l = autotile_wall_edge(autotile, x - 1, y, z)
r = autotile_wall_edge(autotile, x + 1, y, z)
u = autotile_edge(autotile, x, y - 1, z)
d = autotile_edge(autotile, x, y + 1, z)
index = wall_autotile_index(u,d,l,r)
when 0
l = autotile_edge(autotile, x - 1, y, z)
r = autotile_edge(autotile, x + 1, y, z)
u = autotile_edge(autotile, x, y - 1, z)
d = autotile_edge(autotile, x, y + 1, z)
ul = autotile_edge(autotile, x - 1, y - 1, z)
ur = autotile_edge(autotile, x + 1, y - 1, z)
dl = autotile_edge(autotile, x - 1, y + 1, z)
dr = autotile_edge(autotile, x + 1, y + 1, z)
index = normal_autotile_index(u,d,l,r,ul,ur,dl,dr)
end
@map.data[x, y, z] = get_autotile_tile_id(autotile, index)
end
def get_autotile_tile_id(autotile, index)
2048 + (48 * autotile) + index
end
def get_autotile_group(autotile)
return unless autotile
case
when [5, 7, 9, 11, 13, 15].include?(autotile)
return 2
when (48..79).include?(autotile) ||
(88..95).include?(autotile) ||
(104..111).include?(autotile) ||
(120..127).include?(autotile)
return 1
else
return 0
end
end
def waterfall_autotile_index(l,r)
edge = 0
edge |= 1 if l
edge |= 2 if r
return edge
end
def wall_autotile_index(u,d,l,r)
edge = 0
edge |= 1 if l
edge |= 2 if u
edge |= 4 if r
edge |= 8 if d
return edge
end
def normal_autotile_index(u,d,l,r,ul,ur,dl,dr)
edge = 0
edge |= 1 if l
edge |= 2 if u
edge |= 4 if r
edge |= 8 if d
corner = 0
case edge
when 0
corner |= 1 if ul
corner |= 2 if ur
corner |= 4 if dr
corner |= 8 if dl
return corner
when 1
corner |= 1 if ur
corner |= 2 if dr
return 16 | corner
when 2
corner |= 1 if dr
corner |= 2 if dl
return 20 | corner
when 4
corner |= 1 if dl
corner |= 2 if ul
return 24 | corner
when 8
corner |= 1 if ul
corner |= 2 if ur
return 28 | corner
when 5
return 32
when 10
return 33
when 3
return dr ? 35 : 34
when 6
return dl ? 37 : 36
when 12
return ul ? 39 : 38
when 9
return ur ? 41 : 40
when 7
return 42
when 11
return 43
when 13
return 44
when 14
return 45
when 15
return 46
else
return 47
end
end
end
class Game_Interpreter
#swaps the tile at x,y to the specified tile_id
def tile_swap(old_tid, new_tid, layer=0, map_id=$game_map.map_id)
$game_system.add_tile_id(map_id, layer, old_tid, new_tid)
end
def pos_swap(x, y, tid, layer=0, map_id=$game_map.map_id)
$game_system.add_position_tile(map_id, x, y, layer, tid)
end
def region_swap(rid, tid, layer=0, map_id=$game_map.map_id)
$game_system.add_region_tile(map_id, rid, layer, tid)
end
def tile_revert(tid, layer=0, map_id=$game_map.map_id)
$game_system.revert_tile(map_id, layer, tid)
end
def pos_revert(x, y, layer=0, map_id=$game_map.map_id)
$game_system.revert_pos(map_id, x, y, layer)
end
def region_revert(rid, layer=0, map_id=$game_map.map_id)
$game_system.revert_region(map_id, layer, rid)
end
def revert_all(map_id=$game_map.map_id)
$game_system.revert_all(map_id)
end
end
#-------------------------------------------------------------------------------
# Add-on for Overlay Maps
#-------------------------------------------------------------------------------
class Game_Map
alias :th_overlay_naps_load_new_map_data :load_new_map_data
def load_new_map_data
th_overlay_naps_load_new_map_data
@overlay_maps.each {|map| map.load_new_map_data} unless self.is_a?(Game_OverlayMap)
end
alias :th_overlay_maps_reload_map :reload_map
def reload_map
th_overlay_maps_reload_map
@overlay_maps.each {|map| map.reload_map} unless self.is_a?(Game_OverlayMap)
end
end if $imported["TH_OverlayMaps"]Spoiler: (Otwórz)
![[Obrazek: tileSwap1.jpg]](http://dl.dropbox.com/u/23043573/RPG%20Maker/Screenshot/tileSwap1.jpg)
INSTRUKCJA używania skryptu
RE: Podmiana tilesetów - X-Tech - 19-07-14 13:57
pos_swap(x, y, tileID, layer, map_id) (WZÓR)
wpisuję na przykład:
pos_swap(15,16,17,A,2)
i wyskakuje błąd nawołujący do:
game interpreter A
Totalnie bez sensu, a przecież pisze wyraźnie
x,y, koordynaty
tileid - id klocka, na który się zmieni kloc z x,y
layer - warstwa
map_id - id mapy
coś jest nie tak ? Na logikę nie. Gdzie tu sens ?
RE: Podmiana tilesetów - Ayene - 19-07-14 14:02
Bo "layer" nie jest zmienną typu "char" tylko "integer". Spróbuj zamiast "A" w argumentach wywołania wpisać np. "0".
RE: Podmiana tilesetów - X-Tech - 19-07-14 14:05
Już to ogarnąłem musi być:
pos_swap(26, 32, "A17", 2)
layer i id klocka to musi być jedno
RE: Podmiana tilesetów - Ayene - 19-07-14 14:22
Nie musi być jedno, layer to layer, To co wpisałeś "A17" to połaczony tile z jego indeksem. Według Twojego wywołania zmieniasz element z warstwy (layer) drugiej na 17 z zakładki A. Możesz dodać jeszcze jeden argument - ID mapy.
RE: Podmiana tilesetów - X-Tech - 19-07-14 14:52
Zgadza się !
Nie czaję tego layer stąd ten problem.
Ktoś rozumie warstwy z VX ace ?
Zgaduję:
A1,2,3,4,5= layer 1
B= layer 2
C= layer 3
D= layer 4
E= layer 5
?
or
A1=1 layer
A2=2 layer
A3=3 layer
A4=4 layer
A5=5 layer
B=6 layer
C=7 layer
D=8 layer
E=9 layer
?
OR
A1,2,3,4,5 = layer 1
B,C,D,E = layer 2
?
RE: Podmiana tilesetów - Ayene - 19-07-14 15:05
Warstw masz 3, od 0 do 2:
0 to podłoga i ściany z A1-A5.
1 to elementy z A1-A2, które możesz nałożyć na wasrtwę 0, czyli dziury, pęknięcia, lilie, patyki na wodzie, itd.
2 to reszta elementów z B-E.
RE: Podmiana tilesetów - X-Tech - 19-07-14 18:03
http://forums.rpgmakerweb.com/index.php?/topic/14671-embellishment-a2-tiles-and-fieldarea-type/ To jeszcze bardziej popaprane niż sadziłem...Layery zmieniają się wg. ustawienia stylu tileseta. Warstwy są wg. pionowych kolumn.