payam
-
Posts
50 -
Joined
-
Last visited
Content Type
Profiles
Forums
Calendar
Posts posted by payam
-
-
-
Titolo: Job Changing/EXP Script
Autore: Prexus
Istruzioni: All`interno dello script (in inglese)
Link per lo script: http://rm-dev.org"" target="_blank">SCRIPT
-
Mode07
Descrizione
Provvede a trasformare il vostro gioco in 3d
Autore
MGCaladtogel
Allegati
Nessuno
Istruzioni per l'uso
Lo script e` diviso in varie parti da sostituire con i codici originali di rmxp
#============================================================================ # This script adds a kind of depth for the maps. # Written by MGCaladtogel # English version (24/04/08) #---------------------------------------------------------------------------- # Instructions : # You must add to the map's name : #- [M7] : to activate Mode7 #- [#XX] : XX is the slant angle (in degree). Default value is 0 (normal maps) #- [Y] : Y-map looping #- [X] : X-map looping. This option needs resources (lower fps). #- [A] : animated autotiles (with 4 patterns). This option increases # significantly the loading time, so it may crash for large maps # (SystemStackError) #- [C] : to center the map on the hero (even for small maps) #- [P] : to have a fixed panorama #- [H] : to have a white horizon #- [OV] : Overworld Sprite Resize (a Mewsterus's script feature) # # OR : # see the "$mode7_maps_settings" below (l.48) to prapare your settings #---------------------------------------------------------------------------- # Other commands (for events) : #- $scene.spriteset.tilemap.mode7_set(new_angle) # To redraw the map with the new_angle #- $scene.spriteset.tilemap.mode7_set_p(new_angle) # To redraw progressively the map from the current angle to the new #- $scene.spriteset.tilemap.mode7_redraw # To redraw the map (useful with the following commands) #- $game_system.map_opacity = value # To define the opacity for Mode7 maps (it needs to redraw) #- $game_system.map_gradual_opacity = value # To define a gradual opacity for Mode7 maps (it needs to redraw) # (it bugs with horizontal looping) #- $game_system.map_tone = Color.new(Red, Green, Blue) # To define the tone for Mode7 maps (it needs to redraw) #- $game_system.map_gradual_tone = Tone.new(Red, Green, Blue, Gray) # To define a gradual tone for Mode7 maps (it needs to redraw) #- $game_system.horizon = value # To define the view's distance (default : 960) (it needs to redraw) #- $game_system.reset # To initialize the previous options # #- To obtain flat events : # just add a comment in the event's commands list with : "Flat" # #- To handle the height of a vertical event : # add a comment in the event's commands list with : "Heigth X", where X is the # height value ("Heigth 2" will draw the event 64 pixels above its original # position - you can use floats) #============================================================================ # The map is drawn from all the tiles of the three layers that do not have a # terrain_tag's value of 1 or 2. # The other tiles (terrain_tag = 1 or 2) form elements that are drawn vertically, # like the 3rd-layer elements in the old version. # The 2 terrains ID used to form vertical elements $terrain_tags_vertical_tiles = [1,2] # You can modify these values # To access maps names $data_maps = load_data("Data/MapInfos.rxdata") $mode7_maps_settings = {} # Prepare your own settings for mode7 maps # Just put the first parameter in a map's name # For example : $mode7_maps_settings["Worldmap"] = ["#60", "X", "Y", "A", "H", "OV"] # -> will be called when "Worldmap" is included in the name $mode7_maps_settings["Smallslant"] = ["#20", "A", "S"] # Add any number of settings you want # enable/disable mode7 for mode7 maps (not on the fly, just when the map is loaded), enabled by default $enable_mode7_number = 5 # switch number : change this value ! #============================================================================ # ¦ Game_System #---------------------------------------------------------------------------- # Add attributes to this class #============================================================================ class Game_System attr_accessor :mode7 # false : normal map / true : mode 7 attr_accessor :loop_x # true : horizontal-looping map attr_accessor :loop_y # true : vertical-looping map attr_accessor :always_scroll # true : to center the camera around the hero attr_accessor :map_tone # mode7 map's tone (Color) attr_accessor :map_opacity # mode7 map's opacity (0..255) attr_accessor :animated # true : animated autotiles for mode7 maps attr_accessor :white_horizon # true : white line horizon for mode7 maps attr_accessor :angle # mode7 map's slant angle (in degree) attr_accessor :horizon # horizon's distance attr_accessor :fixed_panorama # true : to fix the panorama (no scrolling any more) attr_accessor :ov # true : Overworld Sprite Resize (smaller hero's sprite) attr_accessor :ov_zoom # resize's value with ov attr_accessor :map_gradual_opacity # mode7 map's gradual opacity (0..255) attr_accessor :map_gradual_tone # mode7 map's gradual tone (Color) #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- alias initialize_mode7_game_system initialize def initialize initialize_mode7_game_system self.mode7 = false self.loop_x = false self.loop_y = false self.always_scroll = false self.animated = false self.white_horizon = false self.angle = 0 self.fixed_panorama = false self.ov = false self.ov_zoom = 0.6 reset end #-------------------------------------------------------------------------- # * Reset the values for opacity, tone and horizon's distance #-------------------------------------------------------------------------- def reset self.map_opacity = 255 self.map_tone = Color.new(0,0,0,0) self.horizon = 960 # default value, equivalent to 30 tiles self.map_gradual_opacity = 0 self.map_gradual_tone = Tone.new(0,0,0,0) end end #============================================================================ # ¦ Tilemap_mode7 #---------------------------------------------------------------------------- # This new Tilemap class handles the drawing of a mode7 map #============================================================================ class Tilemap_mode7 attr_accessor :maps_list # contains map's graphics attr_accessor :map_ground # original map's graphic to handle flat events attr_accessor :tone_values # tone values for each line (Hash) attr_accessor :opacity_values # opacity values for each line (Hash) attr_reader :spriteset #-------------------------------------------------------------------------- # * Object Initialization # viewport : viewport #-------------------------------------------------------------------------- def initialize(viewport, spriteset) @spriteset = spriteset @id = $game_map.map_id # map's ID : to load or save the map in Cache @maps_list = [] # contains map's drawings (Bitmap) @disp_y = $game_map.display_y # @disp_y : tilemap's display_y @disp_x = $game_map.display_x # @disp_x : tilemap's display_x @height = 32 * $game_map.height # @height : map's height (in pixel) @width = 32 * $game_map.width # @width : map's width (in pixel) $game_temp.height = @height # map's drawings are loaded if already in Cache if RPG::Cache_Carte.in_cache(@id) @map = RPG::Cache_Carte.load(@id) @maps_list.push(@map) @map_ground = RPG::Cache_Carte.load(@id, 4) # to handle flat events if $game_system.animated @map_2 = RPG::Cache_Carte.load(@id, 1) @map_3 = RPG::Cache_Carte.load(@id, 2) @map_4 = RPG::Cache_Carte.load(@id, 3) @maps_list.push(@map_2) @maps_list.push(@map_3) @maps_list.push(@map_4) end else # draw the map and save it in the Cache draw_map end # create vertical elements from tiles data_V = Data_Vertical_Sprites.new(viewport) # @sprites_V : list of vertical sprites (Sprite_V) @sprites_V = data_V.list_sprites_V # @sprites_V_animated : list of animated vertical sprites (Sprite_V) @sprites_V_animated = data_V.list_sprites_V_animated @angle = $game_system.angle # map's slant angle (in degree) @distance_h = 480 # distance between the map's center and the vanishing point @pivot = 256 # screenline's number of the slant's pivot @index_animated = 0 # 0..3 : index of animated tiles pattern @viewport = viewport @tone_values = {} # list of the tone values for each line @opacity_values = {} # list of the opacity values for each line init_sprites(@angle) # initialize screenlines sprites end #-------------------------------------------------------------------------- # * Dispose #-------------------------------------------------------------------------- def dispose # dispose of @sprites (scanlines), @sprites_V (vertical_sprites), and # @sprites_loop_x (additional scanlines for horizontal looping) for sprite in @sprites + @sprites_V + @sprites_loop_x sprite.dispose end @sprites.clear @sprites_loop_x.clear @sprites_V.clear @sprites_V_animated.clear @maps_list.clear $game_system.angle = @angle end #-------------------------------------------------------------------------- # * Increase slant's angle #-------------------------------------------------------------------------- def increase_angle return if @angle == 88 @angle = [@angle + 2, 88].min # angle's value between 0 and 88 degrees @sprites.clear @sprites_loop_x.clear init_sprites(@angle) # reinitialize screenlines sprites end #-------------------------------------------------------------------------- # * Decrease slant's angle #-------------------------------------------------------------------------- def decrease_angle return if @angle == 0 @angle = [@angle - 2, 0].max # angle's value between 0 and 88 degrees @sprites.clear @sprites_loop_x.clear init_sprites(@angle) # reinitialize screenlines sprites end #-------------------------------------------------------------------------- # * Slide from the current angle into the target value # value : target angle's value (in degree) #-------------------------------------------------------------------------- def mode7_set_p(value) while value > @angle increase_angle spriteset.update Graphics.update end while value < @angle decrease_angle spriteset.update Graphics.update end end #-------------------------------------------------------------------------- # * Redraw the map instantaneously with the new slant angle's value # value : target angle's value (in degree) #-------------------------------------------------------------------------- def mode7_set(value) @angle = [[value, 0].max, 89].min @sprites.clear @sprites_loop_x.clear init_sprites(@angle) # reinitialize screenlines sprites update Graphics.update end #-------------------------------------------------------------------------- # * Reinitialize screenlines sprites #-------------------------------------------------------------------------- def mode7_redraw @sprites.clear @sprites_loop_x.clear init_sprites(@angle) # reinitialize scanlines update Graphics.update end #-------------------------------------------------------------------------- # * Create sprites equivalent to scanlines # value : target angle's value (in degree) #-------------------------------------------------------------------------- def init_sprites(angle) @horizon = $game_system.horizon angle_rad = (Math::PI * angle) / 180 # angle in radian @sprites = [] # list of the scanlines sprites (Sprite) @sprites_loop_x = [] # list of the additionnal sprites (for X-looping) cos_angle = Math.cos(angle_rad) sin_angle = Math.sin(angle_rad) # save values in $game_temp $game_temp.distance_h = @distance_h $game_temp.pivot = @pivot $game_temp.cos_angle = cos_angle $game_temp.sin_angle = sin_angle # h0, z0 : intermediate values h0 = (- @distance_h * @pivot * cos_angle).to_f / (@distance_h + @pivot * sin_angle) + @pivot z0 = @distance_h.to_f / (@distance_h + @pivot * sin_angle) $game_temp.slope_value = (1.0 - z0) / (@pivot - h0) $game_temp.corrective_value = 1.0 - @pivot * $game_temp.slope_value last_line = - @pivot - @horizon # last_line : the highest line that is drawn height_limit = (@distance_h * last_line * cos_angle).to_f / (@distance_h - last_line * sin_angle) + @pivot # the line corresponding to # the last_line in the warped reference = horizon's line $game_temp.height_limit = height_limit # constant to handle gradual opacity k2lim = ((@distance_h * last_line).to_f / (@distance_h * cos_angle + last_line * sin_angle)).to_i # one sprite is created for each screenline for j in 0..479 next if j < height_limit # if the line is further than the horizon's line, # no sprite is created i = j - @pivot # y-reference is the pivot's line sprite = Sprite.new(@viewport) sprite.x = 320 # x-reference is the vertical line in the middle of the screen sprite.y = j sprite.z = - 99999 # map must not mask vertical elements sprite.y_origin_bitmap = (@distance_h * i).to_f / (@distance_h * cos_angle + i * sin_angle) + @pivot sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap + 0.5).to_i sprite.y_origin_bitmap_i %= @height if $game_system.loop_y sprite.zoom_x = $game_temp.slope_value * j + $game_temp.corrective_value sprite.length = 2 + (640.to_f / sprite.zoom_x).to_i sprite.x_origin_bitmap_i = ((642 - sprite.length) / 2) sprite.x_origin_bitmap_i %= @width if $game_system.loop_x sprite.x_origin_bitmap = (sprite.x_origin_bitmap_i).to_f sprite.ox = sprite.length / 2 sprite.bitmap = @map # horizontal translation to center around the hero if @disp_x != 0 sprite.x_origin_bitmap += @disp_x / 4 sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i sprite.x_origin_bitmap_i %= @width if $game_system.loop_x end # vertical translation to center around the hero if @disp_y != 0 sprite.y_origin_bitmap += @disp_y / 4 sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap + 0.5).to_i sprite.y_origin_bitmap_i %= @height if $game_system.loop_y end # handle opacity and tone k2 = ((@distance_h * i).to_f / (@distance_h * cos_angle + i * sin_angle)).to_i k2 = 0 if k2 > 0 k_red = (- k2.to_f/k2lim * $game_system.map_gradual_tone.red).to_i k_green = (- k2.to_f/k2lim * $game_system.map_gradual_tone.green).to_i k_blue = (- k2.to_f/k2lim * $game_system.map_gradual_tone.blue).to_i k_gray = (- k2.to_f/k2lim * $game_system.map_gradual_tone.gray).to_i k2 = (- k2.to_f/k2lim * $game_system.map_gradual_opacity).to_i sprite.tone = Tone.new(k_red, k_green, k_blue, k_gray) sprite.opacity = 255 - k2 sprite.opacity *= ($game_system.map_opacity).to_f / 255 sprite.color = $game_system.map_tone # white horizon's line k = j - height_limit k = 500 / k if $game_system.white_horizon tone_red = sprite.tone.red + k tone_green = sprite.tone.green + k tone_blue = sprite.tone.blue + k tone_gray = sprite.tone.gray + k sprite.tone = Tone.new(tone_red, tone_green, tone_blue, tone_gray) end @tone_values[j] = sprite.tone @opacity_values[j] = sprite.opacity # set sprite's graphics sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) @sprites.push(sprite) if $game_system.loop_x and j < @pivot # additional sprite to handle horizontal looping sprite2 = Sprite.new(@viewport) sprite2.x = 320 sprite2.y = j sprite2.z = - 99999 sprite2.y_origin_bitmap = sprite.y_origin_bitmap sprite2.y_origin_bitmap_i = sprite.y_origin_bitmap_i sprite2.zoom_x = sprite.zoom_x sprite2.length = sprite.length sprite2.x_origin_bitmap_i = sprite.x_origin_bitmap_i - @width sprite2.x_origin_bitmap = sprite.x_origin_bitmap_i - @width sprite2.ox = sprite.ox sprite2.bitmap = @map sprite2.opacity = sprite.opacity sprite2.color = sprite.color sprite2.tone = sprite.tone sprite2.src_rect.set(sprite2.x_origin_bitmap_i, sprite2.y_origin_bitmap_i, sprite2.length, 1) @sprites_loop_x.push(sprite2) end end end #-------------------------------------------------------------------------- # * Update the screenlines sprites and the vertical sprites # compare tilemap's display with map's display #-------------------------------------------------------------------------- def update # update screenlines sprites if @disp_y < $game_map.display_y difference = $game_map.display_y - @disp_y @disp_y += difference for sprite in @sprites + @sprites_loop_x sprite.y_origin_bitmap += difference.to_f / 4 sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap+0.5).to_i sprite.y_origin_bitmap_i %= @height if $game_system.loop_y sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end end if @disp_y > $game_map.display_y difference = @disp_y - $game_map.display_y @disp_y -= difference for sprite in @sprites + @sprites_loop_x sprite.y_origin_bitmap -= difference.to_f / 4 sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap+0.5).to_i sprite.y_origin_bitmap_i %= @height if $game_system.loop_y sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end end if @disp_x < $game_map.display_x difference = $game_map.display_x - @disp_x @disp_x += difference for sprite in @sprites sprite.x_origin_bitmap += difference.to_f / 4 sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i sprite.x_origin_bitmap_i %= @width if $game_system.loop_x sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end for sprite in @sprites_loop_x sprite.x_origin_bitmap += difference.to_f / 4 sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i sprite.x_origin_bitmap_i %= @width sprite.x_origin_bitmap_i -= @width sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end end if @disp_x > $game_map.display_x difference = @disp_x - $game_map.display_x @disp_x -= difference for sprite in @sprites sprite.x_origin_bitmap -= difference.to_f / 4 sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i sprite.x_origin_bitmap_i %= @width if $game_system.loop_x sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end for sprite in @sprites_loop_x sprite.x_origin_bitmap -= difference.to_f / 4 sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i sprite.x_origin_bitmap_i %= @width sprite.x_origin_bitmap_i -= @width sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end end # update vertical sprites for sprite in @sprites_V sprite.update end end #-------------------------------------------------------------------------- # * Update animation for animated tiles #-------------------------------------------------------------------------- def update_animated @index_animated += 1 @index_animated %= 4 map = @maps_list[@index_animated] # update screenlines sprites for sprite in @sprites + @sprites_loop_x sprite.bitmap = map sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i, sprite.length, 1) end # update vertical sprites for sprite in @sprites_V_animated sprite.update_animated(@index_animated) end end #-------------------------------------------------------------------------- # * Create bitmaps representing the map #-------------------------------------------------------------------------- def draw_map data = $game_map.data # Table where animated tiles are flagged data_animated = Table.new($game_map.width, $game_map.height) # bigger maps to handle horizontal looping offset = ($game_system.loop_x ? 640 : 0) @map = Bitmap.new(@width + offset, @height) @maps_list.push(@map) rect = Rect.new(0, 0, 32, 32) # create autotiles graphics RPG::Cache.clear @autotiles = [] for i in 0..6 autotile_name = $game_map.autotile_names[i] fichier = RPG::Cache.autotile(autotile_name) for l in 0..3 data_autotile = Data_Autotiles.new(fichier,l) data_autotile.number = 4*i + l RPG::Cache.save_autotile(data_autotile, data_autotile.number) @autotiles.push(data_autotile) end end # scan map's data to draw it for i in 0...$game_map.height for j in 0...$game_map.width data_animated[j, i] = 0 # tile's ID for the first layer value1 = data[j, i, 0].to_i # prevent from drawing a vertical tile value1 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value1]) ? 0 : value1) # value1 != 0 if value1 != 0 # tile's ID for the second layer value2 = data[j, i, 1].to_i # prevent from drawing a vertical tile value2 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value2]) ? 0 : value2) # tile's ID for the third layer value3 = data[j, i, 2].to_i # prevent from drawing a vertical tile value3 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value3]) ? 0 : value3) # value1 != 0, value2 = 0 if value2 == 0 # value1 != 0, value2 = 0, value3 = 0 if value3 == 0 # value1 associated with a normal autotile if value1 > 383 bitmap = RPG::Cache.tile($game_map.tileset_name, value1, 0) @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end # value1 associated with an autotile else num = 4*((value1 / 48) - 1) bitmap = RPG::Cache.autotile_base(num, value1) if @autotiles[num].animated data_animated[j, i] = 1 end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end end # value1 != 0, value2 = 0, value3 != 0 else bitmap = RPG::Cache_Tile.load(value1, value3) # value1 associated with an autotile if value1 < 384 num = 4*((value1 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end # value3 associated with an autotile if value3 < 384 num = 4*((value3 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end end # value1 != 0, value2 != 0 else # value1 != 0, value2 != 0, value3 = 0 if value3 == 0 bitmap = RPG::Cache_Tile.load(value1, value2) # value1 associated with an autotile if value1 < 384 num = 4*((value1 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end # value2 associated with an autotile if value2 < 384 num = 4*((value2 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end # value1 != 0, value2 != 0, value3 != 0 else bitmap = RPG::Cache_Tile.load2(value1, value2, value3) # value1 associated with an autotile if value1 < 384 num = 4*((value1 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end # value2 associated with an autotile if value2 < 384 num = 4*((value2 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end # value3 associated with an autotile if value3 < 384 num = 4*((value3 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end end end # value1 = 0 else value2 = data[j, i, 1].to_i value2 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value2]) ? 0 : value2) value3 = data[j, i, 2].to_i value3 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value3]) ? 0 : value3) # value1 = 0, value2 = 0 if value2 == 0 # value1 = 0, value2 = 0, value3 != 0 if value3 != 0 # value3 associated with a normal tile if value3 > 383 bitmap = RPG::Cache.tile($game_map.tileset_name, value3, 0) @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end # value3 associated with an autotile else num = 4*((value3 / 48) - 1) bitmap = RPG::Cache.autotile_base(num, value3) if @autotiles[num].animated data_animated[j, i] = 1 end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end end end # value1 = 0, value2 != 0 else # value1 = 0, value2 != 0, value3 = 0 if value3 == 0 # value2 associated with a normal tile if value2 > 383 bitmap = RPG::Cache.tile($game_map.tileset_name, value2, 0) @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end # value2 associated with an autotile else num = 4*((value2 / 48) - 1) bitmap = RPG::Cache.autotile_base(num, value2) if @autotiles[num].animated data_animated[j, i] = 1 end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end end # value1 = 0, value2 != 0, value3 != 0 else bitmap = RPG::Cache_Tile.load(value2, value3) # value2 associated with an autotile if value2 < 384 num = 4*((value2 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end # value3 associated with an autotile if value3 < 384 num = 4*((value3 / 48) - 1) data_animated[j, i] = 1 if @autotiles[num].animated end @map.blt(32*j, 32*i, bitmap, rect) if $game_system.loop_x and j.between?(0, 19) @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect) end end end end end end # save the map's drawing in the Cache RPG::Cache_Carte.save(@id, @map) @map_ground = @map.clone # save a copy of the map to handle flat events RPG::Cache_Carte.save(@id, @map_ground, 4) return if !$game_system.animated # create 3 other maps in case of animated tiles @map_2 = @map.clone @map_3 = @map.clone @map_4 = @map.clone @maps_list.push(@map_2) @maps_list.push(@map_3) @maps_list.push(@map_4) for i in 0...$game_map.height for j in 0...$game_map.width next if data_animated[j, i].to_i == 0 # modify the tile if it is flagged as animated value1 = data[j, i, 0].to_i value2 = data[j, i, 1].to_i value3 = data[j, i, 2].to_i # prevent from drawing a vertical tile value1 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value1]) ? 0 : value1) value2 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value2]) ? 0 : value2) value3 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value3]) ? 0 : value3) if value1 != 0 if value2 == 0 if value3 == 0 num = 4*((value1 / 48) - 1) bitmap_2 = RPG::Cache.autotile_base(num+1, value1) bitmap_3 = RPG::Cache.autotile_base(num+2, value1) bitmap_4 = RPG::Cache.autotile_base(num+3, value1) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end else bitmap_2 = RPG::Cache_Tile.load(value1, value3, 1) bitmap_3 = RPG::Cache_Tile.load(value1, value3, 2) bitmap_4 = RPG::Cache_Tile.load(value1, value3, 3) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end end else if value3 == 0 bitmap_2 = RPG::Cache_Tile.load(value1, value2, 1) bitmap_3 = RPG::Cache_Tile.load(value1, value2, 2) bitmap_4 = RPG::Cache_Tile.load(value1, value2, 3) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end else bitmap_2 = RPG::Cache_Tile.load2(value1, value2, value3, 1) bitmap_3 = RPG::Cache_Tile.load2(value1, value2, value3, 2) bitmap_4 = RPG::Cache_Tile.load2(value1, value2, value3, 3) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end end end else if value2 != 0 if value3 == 0 num = 4*((value2 / 48) - 1) bitmap_2 = RPG::Cache.autotile_base(num+1, value2) bitmap_3 = RPG::Cache.autotile_base(num+2, value2) bitmap_4 = RPG::Cache.autotile_base(num+3, value2) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end else bitmap_2 = RPG::Cache_Tile.load(value2, value3, 1) bitmap_3 = RPG::Cache_Tile.load(value2, value3, 2) bitmap_4 = RPG::Cache_Tile.load(value2, value3, 3) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end end else if value3 != 0 num = 4*((value3 / 48) - 1) bitmap_2 = RPG::Cache.autotile_base(num+1, value3) bitmap_3 = RPG::Cache.autotile_base(num+2, value3) bitmap_4 = RPG::Cache.autotile_base(num+3, value3) @map_2.blt(32*j, 32*i, bitmap_2, rect) @map_3.blt(32*j, 32*i, bitmap_3, rect) @map_4.blt(32*j, 32*i, bitmap_4, rect) if $game_system.loop_x and j.between?(0, 19) @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect) @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect) @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect) end end end end end end # save the three additional maps in the Cache RPG::Cache_Carte.save(@id, @map_2, 1) RPG::Cache_Carte.save(@id, @map_3, 2) RPG::Cache_Carte.save(@id, @map_4, 3) end #-------------------------------------------------------------------------- # * no tileset for mode7 maps #-------------------------------------------------------------------------- def tileset return nil end end #============================================================================ # This script adds a kind of depth for the maps. # Written by MGCaladtogel # English version (24/04/08) #============================================================================ # ¦ Game_Map #---------------------------------------------------------------------------- # Methods modifications to handle map looping #============================================================================ class Game_Map #-------------------------------------------------------------------------- # * Scroll Down # distance : scroll distance #-------------------------------------------------------------------------- alias scroll_down_mode7_game_map scroll_down def scroll_down(distance) if !$game_system.mode7 scroll_down_mode7_game_map(distance) return end if $game_system.loop_y or $game_system.always_scroll @display_y = @display_y + distance # always scroll else @display_y = [@display_y + distance, (self.height - 15) * 128].min end end #-------------------------------------------------------------------------- # * Scroll Left # distance : scroll distance #-------------------------------------------------------------------------- alias scroll_left_mode7_game_map scroll_left def scroll_left(distance) if !$game_system.mode7 scroll_left_mode7_game_map(distance) return end if $game_system.loop_x or $game_system.always_scroll @display_x = @display_x - distance # always scroll else @display_x = [@display_x - distance, 0].max end end #-------------------------------------------------------------------------- # * Scroll Right # distance : scroll distance #-------------------------------------------------------------------------- alias scroll_right_mode7_game_map scroll_right def scroll_right(distance) if !$game_system.mode7 scroll_right_mode7_game_map(distance) return end if $game_system.loop_x or $game_system.always_scroll @display_x = @display_x + distance # always scroll else @display_x = [@display_x + distance, (self.width - 20) * 128].min end end #-------------------------------------------------------------------------- # * Scroll Up # distance : scroll distance #-------------------------------------------------------------------------- alias scroll_up_mode7_game_map scroll_up def scroll_up(distance) if !$game_system.mode7 scroll_up_mode7_game_map(distance) return end if $game_system.loop_y or $game_system.always_scroll @display_y = @display_y - distance # always scroll else @display_y = [@display_y - distance, 0].max end end #-------------------------------------------------------------------------- # * Determine Valid Coordinates # x : x-coordinate # y : y-coordinate # Allow the hero to go out of the map when map looping #-------------------------------------------------------------------------- alias valid_mode7_game_map? valid? def valid?(x, y) if !$game_system.mode7 return (valid_mode7_game_map?(x, y)) end if $game_system.loop_x if $game_system.loop_y return true else return (y >= 0 and y < height) end elsif $game_system.loop_y return (x >= 0 and x < width) end return (x >= 0 and x < width and y >= 0 and y < height) end #-------------------------------------------------------------------------- # * Determine if Passable # x : x-coordinate # y : y-coordinate # d : direction (0,2,4,6,8,10) # * 0,10 = determine if all directions are impassable # self_event : Self (If event is determined passable) #-------------------------------------------------------------------------- alias passable_mode7_game_map? passable? def passable?(x, y, d, self_event = nil) if !$game_system.mode7 passable_mode7_game_map?(x, y, d, self_event) return(passable_mode7_game_map?(x, y, d, self_event)) end unless valid?(x, y) return false end bit = (1 = 0 and event != self_event and event.x == x and event.y == y and not event.through if @passages[event.tile_id] & bit != 0 return false elsif @passages[event.tile_id] & 0x0f == 0x0f return false elsif @priorities[event.tile_id] == 0 return true end end end for i in [2, 1, 0] tile_id = data[x % width, y % height, i] # handle map looping if tile_id == nil return false elsif @passages[tile_id] & bit != 0 return false elsif @passages[tile_id] & 0x0f == 0x0f return false elsif @priorities[tile_id] == 0 return true end end return true end #-------------------------------------------------------------------------- # * Setup # map_id : map ID #-------------------------------------------------------------------------- alias old_setup_mode7 setup def setup(map_id) old_setup_mode7(map_id) if !$game_switches[$enable_mode7_number] $game_system.mode7 = false $game_system.mode7 = false $game_system.loop_x = false $game_system.loop_y = false $game_system.always_scroll = false $game_system.animated = false $game_system.white_horizon = false $game_system.angle = 0 $game_system.fixed_panorama = false $game_system.ov = false $game_system.ov_zoom = 0.6 $game_system.reset return end map_data = $data_maps[$game_map.map_id] for keyword in $mode7_maps_settings.keys if map_data.name2.include?(keyword) command_list = $mode7_maps_settings[keyword] $game_system.mode7 = true $game_system.loop_x = command_list.include?("X") $game_system.loop_y = command_list.include?("Y") $game_system.always_scroll = command_list.include?("C") $game_system.animated = command_list.include?("A") $game_system.white_horizon = command_list.include?("H") $game_system.fixed_panorama = command_list.include?("P") $game_system.ov = command_list.include?("OV") for command in command_list if command.include?("#") $game_system.angle = (command.slice(1, 2)).to_i $game_system.angle = [[$game_system.angle, 0].max, 89].min break end end return end end $game_system.mode7 = map_data.name2.include?("[M7]") $game_system.loop_x = map_data.name2.include?("[X]") $game_system.loop_y = map_data.name2.include?("[Y]") $game_system.always_scroll = map_data.name2.include?("[C]") $game_system.animated = map_data.name2.include?("[A]") $game_system.white_horizon = map_data.name2.include?("[H]") $game_system.fixed_panorama = map_data.name2.include?("[P]") $game_system.ov = map_data.name2.include?("[OV]") if $game_system.mode7 map_data.name2 =~ /\[#[ ]*([00-99]+)\]/i $game_system.angle = $1.to_i $game_system.angle = [[$game_system.angle, 0].max, 89].min end end end #============================================================================ # ¦ Game_Character #---------------------------------------------------------------------------- # "update" method modifications to handle map looping #============================================================================ class Game_Character attr_accessor :x attr_accessor :y attr_accessor :real_x attr_accessor :real_y attr_reader :flat attr_reader :height #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- alias initialize_mode7_game_character initialize def initialize initialize_mode7_game_character @flat = false @height = 0.0 end #-------------------------------------------------------------------------- # * Update #-------------------------------------------------------------------------- alias update_mode7_game_character update def update if !$game_system.mode7 update_mode7_game_character return end # if x-coordinate is out of the map if !(x.between?(0, $game_map.width - 1)) difference = 128 * x - real_x if self.is_a?(Game_Player) # increase or decrease map's number self.map_number_x += difference / (difference.abs) end # x-coordinate is equal to its equivalent in the map self.x %= $game_map.width self.real_x = 128 * x - difference end # if y-coordinate is out of the map if !(y.between?(0, $game_map.height - 1)) difference = 128 * y - real_y if self.is_a?(Game_Player) # increase or decrease map's number self.map_number_y += difference / (difference.abs) end # y-coordinate is equal to its equivalent in the map self.y %= $game_map.height self.real_y = 128 * y - difference end update_mode7_game_character end end #============================================================================== # ¦ Game_Event #---------------------------------------------------------------------------- # Add methods to handle flat events and altitude for vertical event #============================================================================ class Game_Event < Game_Character #-------------------------------------------------------------------------- # * scan the event's commands list # page : the scanned page (RPG::Event::Page) #-------------------------------------------------------------------------- def check_commands(page) @height = 0.0 command_list = page.list for k in 0..command_list.length - 2 command = command_list[k] if (command.parameters[0].to_s).include?("Height") @height = (command.parameters[0][7,command.parameters[0].length-1]).to_f end @flat = (command.parameters[0].to_s).include?("Flat") end end #-------------------------------------------------------------------------- # * scan the event's commands list of the current page when refreshed #-------------------------------------------------------------------------- alias refresh_mode7_game_character refresh def refresh refresh_mode7_game_character check_commands(@page) if @page != nil end end #============================================================================ # ¦ Game_Player #---------------------------------------------------------------------------- # Add attributes to have a well-working panorama's scrolling #============================================================================ class Game_Player < Game_Character attr_accessor :map_number_x # map's number with X-looping attr_accessor :map_number_y # map's number with Y-looping #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- alias initialize_mode7_game_player initialize def initialize initialize_mode7_game_player self.map_number_x = 0 self.map_number_y = 0 end #-------------------------------------------------------------------------- # * Handle the option : center around the hero #-------------------------------------------------------------------------- alias center_mode7_game_player center def center(x, y) if !$game_system.loop_y and !$game_system.always_scroll#!$game_system.mode7 center_mode7_game_player(x, y) return end $game_map.display_x = x * 128 - CENTER_X $game_map.display_y = y * 128 - CENTER_Y end end #============================================================================ # ¦ Sprite #---------------------------------------------------------------------------- # Add attributes to work efficiently with scanlines sprites #============================================================================ class Sprite attr_accessor :y_origin_bitmap # bitmap's y-coordinate for the "src_rect.set" #method (float) attr_accessor :x_origin_bitmap # bitmap's x-coordinate for the "src_rect.set" #method (float) attr_accessor :y_origin_bitmap_i # bitmap's y-coordinate for the #"src_rect.set" method (integer) attr_accessor :x_origin_bitmap_i # bitmap's x-coordinate for the #"src_rect.set" method (integer) attr_accessor :length # sprite's width end #============================================================================ # ¦ Sprite_Character #---------------------------------------------------------------------------- # Calculate x-coordinate and y-coordinate for a mode7 map #============================================================================ class Sprite_Character < RPG::Sprite attr_reader :flat_indicator # true if the event is flat-drawn #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- alias initialize_mode7_sprite_character initialize def initialize(viewport, character = nil) @flat_indicator = false initialize_mode7_sprite_character(viewport, character) end #-------------------------------------------------------------------------- # * Update #-------------------------------------------------------------------------- alias update_mode7_sprite_character update def update if !$game_system.mode7 update_mode7_sprite_character return end if @flat_indicator if (!@character.flat or @character.moving? or @tile_id != @character.tile_id or @character_name != @character.character_name or @character_hue != @character.character_hue) @flat_indicator = @character.flat # redraw the original ground maps_list = $scene.spriteset.tilemap.maps_list map_ground = $scene.spriteset.tilemap.map_ground rect = Rect.new(@flat_x_map, @flat_y_map, @flat_width, @flat_height) for map in maps_list map.blt(@flat_x_map, @flat_y_map, map_ground, rect) if $game_system.loop_x and @flat_x_map.between?(0, 19 * 32) map.blt(@flat_x_map + 32 * $game_map.width, @flat_y_map, map_ground, rect) end end else return end end super if @tile_id != @character.tile_id or @character_name != @character.character_name or @character_hue != @character.character_hue @tile_id = @character.tile_id @character_name = @character.character_name @character_hue = @character.character_hue if @tile_id >= 384 self.bitmap = RPG::Cache.tile($game_map.tileset_name, @tile_id, @character.character_hue) self.src_rect.set(0, 0, 32, 32) self.ox = 16 self.oy = 32 else self.bitmap = RPG::Cache.character(@character.character_name, @character.character_hue) @cw = bitmap.width / 4 @ch = bitmap.height / 4 self.ox = @cw / 2 self.oy = @ch # pivot correction (intersection between the map and this sprite) self.oy -= 4 end end self.visible = (not @character.transparent) if @tile_id == 0 sx = @character.pattern * @cw sy = (@character.direction - 2) / 2 * @ch self.src_rect.set(sx, sy, @cw, @ch) end if @character.flat # event must be flat drawn return if $scene.spriteset == nil if @tile_id == 0 @flat_x_map = @character.real_x / 4 - (@cw - 32) / 2 @flat_y_map = @character.real_y / 4 - @ch + 32 @flat_x0 = sx @flat_y0 = sy @flat_width = @cw @flat_height = @ch else @flat_x_map = @character.real_x / 4 @flat_y_map = @character.real_y / 4 @flat_x0 = 0 @flat_y0 = 0 @flat_width = 32 @flat_height = 32 end # modify the maps graphics maps_list = $scene.spriteset.tilemap.maps_list rect = Rect.new(@flat_x0, @flat_y0, @flat_width, @flat_height) for map in maps_list map.blt(@flat_x_map, @flat_y_map, bitmap, rect, @character.opacity) if $game_system.loop_x and @flat_x_map.between?(0, 19 * 32) map.blt(@flat_x_map + 32 * $game_map.width, @flat_y_map, bitmap, rect, @character.opacity) end end @flat_indicator = true self.opacity = 0 return end x_intermediate = @character.screen_x y_intermediate = @character.screen_y y_intermediate -= $game_temp.pivot + 4 if $game_system.mode7 # if vertical looping if $game_system.loop_y h = 32 * $game_map.height y_intermediate = (y_intermediate + h / 2) % h - h / 2 end # coordinates in a mode7 map self.y = (($game_temp.distance_h * y_intermediate * $game_temp.cos_angle).to_f / ($game_temp.distance_h - y_intermediate * $game_temp.sin_angle) + $game_temp.pivot) self.zoom_x = $game_temp.slope_value * y + $game_temp.corrective_value self.zoom_y = zoom_x self.x = 320 + zoom_x * (x_intermediate - 320) # if horizontal looping if $game_system.loop_x offset = ($game_map.width >= 24 ? 64 * zoom_x : 0) l = 32 * $game_map.width * zoom_x self.x = (x + offset) % l - offset end if @character.is_a?(Game_Player) # Overworld Sprite Resize if $game_system.ov self.zoom_x *= $game_system.ov_zoom self.zoom_y *= $game_system.ov_zoom end end self.z = @character.screen_z(@ch) # hide the sprite if it is beyond the horizon's line self.opacity = (y < $game_temp.height_limit ? 0 : @character.opacity) self.y -= 32 * @character.height * zoom_y # height correction self.blend_type = @character.blend_type self.bush_depth = @character.bush_depth if @character.animation_id != 0 animation = $data_animations[@character.animation_id] animation(animation, true) @character.animation_id = 0 end end end #============================================================================ # ¦ Sprite_V (Vertical Sprites) #---------------------------------------------------------------------------- # Sprites corresponding to the vertical elements formed by tiles #============================================================================ class Sprite_V < Sprite attr_accessor :x_map # sprite's x_coordinates (in squares) (Float) attr_accessor :y_map # sprite's y_coordinates (in squares) (Float) attr_accessor :square_y # sprite's y_coordinates (in squares) (Integer) attr_accessor :priority # sprite's priority attr_accessor :animated # True if animated attr_accessor :list_bitmap # list of sprite's bitmaps (Bitmap) #-------------------------------------------------------------------------- # * Update #-------------------------------------------------------------------------- def update square_y_corrected = square_y y_intermediate = 32 * y_map - $game_temp.pivot - $game_map.display_y / 4 y_intermediate_reference = y_intermediate # if vertical looping if $game_system.loop_y y_intermediate = (y_intermediate + $game_temp.height / 2) % $game_temp.height - $game_temp.height / 2 if y_intermediate_reference < y_intermediate square_y_corrected = square_y + $game_map.height elsif y_intermediate_reference > y_intermediate square_y_corrected = square_y - $game_map.height end end self.y = ($game_temp.distance_h * y_intermediate * $game_temp.cos_angle).to_f / ($game_temp.distance_h - y_intermediate * $game_temp.sin_angle) + $game_temp.pivot if y < $game_temp.height_limit # hide the sprite if it is beyond the horizon's line self.opacity = 0 return end self.opacity = 255 if $scene.spriteset != nil and $scene.spriteset.tilemap.is_a?(Tilemap_mode7) opacity_values = $scene.spriteset.tilemap.opacity_values tone_values = $scene.spriteset.tilemap.tone_values if opacity_values.has_key?(y) self.opacity = opacity_values[y] self.tone = tone_values[y] end end self.zoom_x = $game_temp.slope_value * y + $game_temp.corrective_value self.zoom_y = zoom_x x_intermediate = 32 * x_map - $game_map.display_x / 4 self.x = 320 + (zoom_x * (x_intermediate - 320)) # if horizontal looping if $game_system.loop_x offset = ($game_map.width >= 24 ? 64 * zoom_x : 0) l = 32 * $game_map.width * self.zoom_x self.x = (self.x + offset) % l - offset end self.z = (128 * square_y_corrected - $game_map.display_y + 3) / 4 + 32 + 32 * priority return end #-------------------------------------------------------------------------- # * Update bitmap for animation # index : 0..3 : animation's index #-------------------------------------------------------------------------- def update_animated(index) self.bitmap = @list_bitmap[index] end end #============================================================================ # ¦ Spriteset_Map #---------------------------------------------------------------------------- # Modifications to call a mode7 map #============================================================================ class Spriteset_Map attr_accessor :tilemap # just to be able to access the tilemap #-------------------------------------------------------------------------- # * Initialize Object # Rewritten to call a map with mode7 #-------------------------------------------------------------------------- alias initialize_mode7_spriteset_map initialize def initialize if !$game_system.mode7 initialize_mode7_spriteset_map return end @viewport1 = Viewport.new(0, 0, 640, 480) @viewport2 = Viewport.new(0, 0, 640, 480) @viewport3 = Viewport.new(0, 0, 640, 480) @viewport2.z = 200 @viewport3.z = 5000 # mode7 map @tilemap = Tilemap_mode7.new(@viewport1, self) @panorama = Plane.new(@viewport1) # sprites drawn at the horizon's level have a negative z, and with a z value # of -100000 the panorama is still below @panorama.z = ($game_system.mode7 ? -100000 : -1000) @fog = Plane.new(@viewport1) @fog.z = 3000 @character_sprites = [] for i in $game_map.events.keys.sort sprite = Sprite_Character.new(@viewport1, $game_map.events[i]) @character_sprites.push(sprite) end @character_sprites.push(Sprite_Character.new(@viewport1, $game_player)) @weather = RPG::Weather.new(@viewport1) @picture_sprites = [] for i in 1..50 @picture_sprites.push(Sprite_Picture.new(@viewport2, $game_screen.pictures[i])) end @timer_sprite = Sprite_Timer.new update end #-------------------------------------------------------------------------- # * Dispose #-------------------------------------------------------------------------- def dispose if @tilemap.tileset != nil @tilemap.tileset.dispose for i in 0..6 @tilemap.autotiles[i].dispose end end @tilemap.dispose @panorama.dispose @fog.dispose for sprite in @character_sprites sprite.dispose end @weather.dispose for sprite in @picture_sprites sprite.dispose end @timer_sprite.dispose @viewport1.dispose @viewport2.dispose @viewport3.dispose end #-------------------------------------------------------------------------- # * Update #-------------------------------------------------------------------------- alias update_mode7_spriteset_map update def update if !$game_system.mode7 update_mode7_spriteset_map return end if @panorama_name != $game_map.panorama_name or @panorama_hue != $game_map.panorama_hue @panorama_name = $game_map.panorama_name @panorama_hue = $game_map.panorama_hue if @panorama.bitmap != nil @panorama.bitmap.dispose @panorama.bitmap = nil end if @panorama_name != "" @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue) end Graphics.frame_reset end if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue @fog_name = $game_map.fog_name @fog_hue = $game_map.fog_hue if @fog.bitmap != nil @fog.bitmap.dispose @fog.bitmap = nil end if @fog_name != "" @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue) end Graphics.frame_reset end # update animated tiles each 20 frames if Graphics.frame_count % 20 == 0 and $game_system.animated @tilemap.update_animated end @tilemap.update # if the panorama is fixed if $game_system.fixed_panorama @panorama.ox = 0 @panorama.oy = 0 # if it is a mode7 map else # to have a fluent panorama scrolling @panorama.ox = (128 * $game_map.width * $game_player.map_number_x + $game_player.real_x) / 8 @panorama.oy = - (128 * $game_map.height * $game_player.map_number_y + $game_player.real_y) / 32 end @fog.zoom_x = $game_map.fog_zoom / 100.0 @fog.zoom_y = $game_map.fog_zoom / 100.0 @fog.opacity = $game_map.fog_opacity @fog.blend_type = $game_map.fog_blend_type @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy @fog.tone = $game_map.fog_tone for sprite in @character_sprites sprite.update end @weather.type = $game_screen.weather_type @weather.max = $game_screen.weather_max @weather.ox = $game_map.display_x / 4 @weather.oy = $game_map.display_y / 4 @weather.update for sprite in @picture_sprites sprite.update end @timer_sprite.update @viewport1.tone = $game_screen.tone @viewport1.ox = $game_screen.shake @viewport3.color = $game_screen.flash_color @viewport1.update @viewport3.update end end #============================================================================ # This script adds a kind of depth for the maps. # Written by MGCaladtogel # English version (24/04/08) #============================================================================== # ¦ Game_Switches #============================================================================== class Game_Switches #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- alias initialize_mode7_game_player initialize def initialize initialize_mode7_game_player self[$enable_mode7_number] = true end end #============================================================================ # ¦ Scene_Map #============================================================================ class Scene_Map attr_accessor :spriteset # just need to access the spriteset end #============================================================================ # ¦ Data_Autotiles #---------------------------------------------------------------------------- # Creates the set of tiles from an autotile's file #============================================================================ class Data_Autotiles < Bitmap # data list to form tiles from an atotiles file Data_creation = [[27,28,33,34],[5,28,33,34],[27,6,33,34],[5,6,33,34], [27,28,33,12],[5,28,33,12],[27,6,33,12],[5,6,33,12],[27,28,11,34], [5,28,11,34],[27,6,11,34],[5,6,11,34],[27,28,11,12],[5,28,11,12], [27,6,11,12],[5,6,11,12],[25,26,31,32],[25,6,31,32],[25,26,31,12], [25,6,31,12],[15,16,21,22],[15,16,21,12],[15,16,11,22],[15,16,11,12], [29,30,35,36],[29,30,11,36],[5,30,35,36],[5,30,11,36],[39,40,45,46], [5,40,45,46],[39,6,45,46],[5,6,45,46],[25,30,31,36],[15,16,45,46], [13,14,19,20],[13,14,19,12],[17,18,23,24],[17,18,11,24],[41,42,47,48], [5,42,47,48],[37,38,43,44],[37,6,43,44],[13,18,19,24],[13,14,43,44], [37,42,43,48],[17,18,47,48],[13,18,43,48],[13,18,43,48]] attr_accessor :number # autotile's number to identify it attr_accessor :animated # TRUE if the autotile is animated #-------------------------------------------------------------------------- # * Initialize Object # file : autotiles file's bitmap (Bitmap) # l : 0..3 : pattern's number for animated autotiles #-------------------------------------------------------------------------- def initialize(file, l) super(8*32, 6*32) create(file, l) end #-------------------------------------------------------------------------- # * Create the tiles set # file : autotiles file's bitmap (Bitmap) # l : 0..3 : pattern's number for animated autotiles #-------------------------------------------------------------------------- def create(file, l) l = (file.width > 96 ? l : 0) self.animated = (file.width > 96) for i in 0..5 for j in 0..7 data = Data_creation[8 * i + j] for number in data number -= 1 m = 16 * (number % 6) n = 16 * (number / 6) blt(32 * j + m % 32, 32 * i + n % 32, file, Rect.new(m + 96 * l, n, 16, 16)) end end end end end #============================================================================ # ¦ Data_Vertical_Sprites #---------------------------------------------------------------------------- # Create a list of vertical sprites for the three layers of a map # "V" for "Vertical" in the script # "num" for "number" #============================================================================ class Data_Vertical_Sprites attr_accessor :list_sprites_V # list of vertical sprites attr_accessor :list_sprites_V_animated # list of animated vertical sprites #-------------------------------------------------------------------------- # * A little method to compare terrain_tags # value : tile's ID # num : reference terrain_tag's value #-------------------------------------------------------------------------- def suitable?(value, num) return ($game_map.terrain_tags[value] == num) end #-------------------------------------------------------------------------- # * This algorithm scans each layer and create a sprites formed by tiles # in contact # viewport : Viewport #-------------------------------------------------------------------------- def initialize(viewport) @viewport = viewport # lists initialization self.list_sprites_V = [] self.list_sprites_V_animated = [] # @num_tiles : list of tiles coordinates that form a vertical sprite @num_tiles = [] # create copy of map's data @dataV = ($game_map.data).clone # scan each layer for h in 0..2 # scan each row for i in 0..$game_map.height # scan each column for j in 0..$game_map.width value = @dataV[j, i, h].to_i # if tile's terrain tag is declared to give vertical sprites if $terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value]) @reference_terrain_tag = $game_map.terrain_tags[value] @num_tiles.push([j, i]) # the following algorithm is so complex that I really don't know how # it works exactly list_end = 0 length = 0 while j + length + 1 < $game_map.width and suitable?(@dataV[j +length+ 1, i, h].to_i, @reference_terrain_tag) @num_tiles.push([j + length+ 1,i]) length += 1 end list_start = j list_end = length + j indicator = true row = 0 j2 = j while indicator row += 1 break if (i + row) == $game_map.height list_start2 = j2 length2 = 0 indicator = false if length >= 2 for k in (j2 + 1)..(j2 + length -1) if suitable?(@dataV[k, i + row, h].to_i, @reference_terrain_tag) if !indicator list_start2 = k else length2 = k - list_start2 end indicator = true @num_tiles.push([k, i + row]) elsif !indicator length2 -= 1 end end end if suitable?(@dataV[j2 + length, i + row, h].to_i, @reference_terrain_tag) length2 = j2 + length - list_start2 indicator = true @num_tiles.push([j2 + length, i + row]) length3 = 1 while j2 + length + length3 < $game_map.width and suitable?(@dataV[j2 + length + length3, i + row, h].to_i, @reference_terrain_tag) @num_tiles.push([j2 + length + length3, i + row]) length3 += 1 length2 += 1 if j2 + length + length3 > list_end list_end = j2 + length + length3 end end end if suitable?(@dataV[j2, i + row, h].to_i, @reference_terrain_tag) list_start3 = list_start2 - j2 length2 = length2 + list_start3 list_start2 = j2 indicator = true @num_tiles.push([j2, i + row]) length3 = 1 while j2 - length3 >= 0 and suitable?(@dataV[j2 - length3, i + row, h].to_i, @reference_terrain_tag) @num_tiles.push([j2 - length3, i + row]) length3 += 1 length2 += 1 list_start2 -= 1 if list_start2 < list_start list_start = list_start2 end end end length = length2 j2 = list_start2 end row -= 1 # create a bitmap and a sprite from the tiles listed in @num_tiles create_bitmap(i, list_start, row, list_end - list_start, h) # clear the used tiles clear_data(h) # reinitialize the list of tiles @num_tiles = [] end end end end end #-------------------------------------------------------------------------- # * Clear the used data to prevent from reusing them # layer : current scanned layer #-------------------------------------------------------------------------- def clear_data(layer) for num in @num_tiles @dataV[num[0], num[1], layer] = 0 end end #-------------------------------------------------------------------------- # * Create a Bitmap from the listed tiles in @num_tiles and its associated # sprite (Sprite_V) # row : start row's value # column : start column's value # height : sprite's height (in tiles) # width : sprite's width (in tiles) # layer : current scanned layer #-------------------------------------------------------------------------- def create_bitmap(row, column, height, width, layer) bmp = Bitmap.new(32*(1+width), 32*(1+height)) rect = Rect.new(0, 0, 32, 32) @num_tiles.sort! {|a, b| -(a[1] - b[1])} sprite = Sprite_V.new(@viewport) # initialize sprite's attributes sprite.animated = false sprite.list_bitmap = [] # draw the bitmap for tile_coordinates in @num_tiles value = @dataV[tile_coordinates[0], tile_coordinates[1], layer].to_i # if tile is a normal tile if value > 383 bitmap = RPG::Cache.tile($game_map.tileset_name, value, 0) else # tile is an autotile file = (value / 48) - 1 num_file = 4 * file if !sprite.animated autotile_name = $game_map.autotile_names[file] fichier = RPG::Cache.autotile(autotile_name) sprite.animated = (fichier.width > 96 ? true : false) end bitmap = RPG::Cache.autotile_base(num_file, value) end bmp.blt(32 * (tile_coordinates[0] - column), 32 * (tile_coordinates[1] - row), bitmap, rect) end sprite.list_bitmap.push(bmp) # create 3 additionnal bitmaps for animated sprites if sprite.animated for j in 1..3 bmp = Bitmap.new(32 * (1 + width), 32 * (1 + height)) for tile_coordinates in @num_tiles value = @dataV[tile_coordinates[0], tile_coordinates[1], layer].to_i if value > 383 bitmap = RPG::Cache.tile($game_map.tileset_name, value, 0) else num_file = 4 * ((value / 48) - 1) bitmap = RPG::Cache.autotile_base(num_file + j, value) end bmp.blt(32 * (tile_coordinates[0] - column), 32 * (tile_coordinates[1] - row), bitmap, rect) end sprite.list_bitmap.push(bmp) end end value = @dataV[@num_tiles[0][0], @num_tiles[0][1], layer].to_i # set sprite's priority sprite.priority = $game_map.priorities[value] # set sprite's coordinates (in squares (32 * 32 pixels)) sprite.x_map = (column.to_f) + bmp.width / 64 sprite.x_map += 0.5 if width % 2 == 0 sprite.y_map = (row + height).to_f + 0.5 sprite.square_y = sprite.y_map.to_i # Integer # set the y_pivot (intersection between the map and the sprite) sprite.oy = bmp.height - 16 sprite.ox = bmp.width / 2 sprite.bitmap = sprite.list_bitmap[0] self.list_sprites_V.push(sprite) self.list_sprites_V_animated.push(sprite) if sprite.animated end end #============================================================================ # ¦ RPG::Cache_Tile #---------------------------------------------------------------------------- # The tiles resulting in a superimposing of several tiles are kept in memory # for a faster call # valueX : tile's ID #============================================================================ module RPG module Cache_Tile @cache = {} #------------------------------------------------------------------------ # * Superimposing of two tiles, offset = pattern's number for animated # autotiles #------------------------------------------------------------------------ def self.load(value1, value2, offset=0) if not @cache.include?([value1, value2, offset]) bitmap = Bitmap.new(32, 32) rect = Rect.new(0, 0, 32, 32) if value1 > 383 # normal tile bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value1, 0), rect) else # autotile num = 4*((value1 / 48) - 1) + offset bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value1), rect) end if value2 > 383 # normal tile bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value2, 0), rect) else # autotile num = 4*((value2 / 48) - 1) + offset bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value2), rect) end @cache[[value1, value2, offset]] = bitmap end @cache[[value1, value2, offset]] end #------------------------------------------------------------------------ # * Superimposing of three tiles #------------------------------------------------------------------------ def self.load2(value1, value2, value3, offset = 0) if not @cache.include?([value1, value2, value3, offset]) bitmap = Bitmap.new(32, 32) rect = Rect.new(0, 0, 32, 32) if value1 > 383 # normal tile bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value1, 0), rect) else # autotile num = 4*((value1 / 48) - 1) + offset bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value1), rect) end if value2 > 383 # normal tile bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value2, 0), rect) else # autotile num = 4*((value2 / 48) - 1) + offset bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value2), rect) end if value3 > 383 # normal tile bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value3, 0), rect) else # autotile num = 4*((value3 / 48) - 1) + offset bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value3), rect) end @cache[[value1, value2, value3, offset]] = bitmap end @cache[[value1, value2, value3, offset]] end #------------------------------------------------------------------------ # * Clear the Cache #------------------------------------------------------------------------ def self.clear @cache = {} GC.start end end end #============================================================================ # ¦ RPG::Cache_Carte #---------------------------------------------------------------------------- # Maps drawn with mode7 are kept in memory to have a faster call the next # times they need to be drawn #============================================================================ module RPG module Cache_Carte @cache = {} #------------------------------------------------------------------------ # * Check if the map is in the Cache # map_id : map's ID #------------------------------------------------------------------------ def self.in_cache(map_id) return @cache.include?(map_id) end #------------------------------------------------------------------------ # * Return the map's drawing (Bitmap) # map_id : map's ID # num : pattern's number for animated autotiles #------------------------------------------------------------------------ def self.load(map_id, num = 0) return @cache[map_id][num] end #------------------------------------------------------------------------ # * Save the map's drawing in the Cache # map_id : map's ID # bitmap : map's drawing (Bitmap) # num : pattern's number for animated autotiles #------------------------------------------------------------------------ def self.save(map_id, bitmap, num = 0) @cache[map_id] = [] if !self.in_cache(map_id) @cache[map_id][num] = bitmap end #------------------------------------------------------------------------ # * Clear the Cache #------------------------------------------------------------------------ def self.clear @cache = {} GC.start end end end #============================================================================ # ¦ RPG::Cache #---------------------------------------------------------------------------- # The tiles from autotiles files are kept in memory for a faster call #============================================================================ module RPG module Cache #------------------------------------------------------------------------ # * Check if the map is in the Cache # num : autotiles file's ID # value : tile's ID #------------------------------------------------------------------------ def self.autotile_base(num, value) key = [num, value] if not @cache.include?(key) or @cache[key].disposed? @cache[key] = Bitmap.new(32, 32) num_tile = value % 48 sx = 32 * (num_tile % 8) sy = 32 * (num_tile / 8) rect = Rect.new(sx, sy, 32, 32) @cache[key].blt(0, 0, self.load_autotile(num), rect) end @cache[key] end #------------------------------------------------------------------------ # * Save the tile's drawing in the Cache # bitmap : tile's drawing (Bitmap) # key : tile's ID #------------------------------------------------------------------------ def self.save_autotile(bitmap, key) @cache[key] = bitmap end #------------------------------------------------------------------------ # * Return the tile's drawing (Bitmap) # key : tile's ID #------------------------------------------------------------------------ def self.load_autotile(key) @cache[key] end end end #============================================================================ # ¦ RPG::MapInfo #============================================================================ class RPG::MapInfo # defines the map's name as the name without anything within brackets, # including brackets def name return @name.gsub(/\[.*\]/) {""} end #-------------------------------------------------------------------------- # the original name with the codes def name2 return @name end end #============================================================================ # ¦ Game_Temp #---------------------------------------------------------------------------- # Add attributes to this class / Avoid using too many global variables #============================================================================ class Game_Temp attr_accessor :pivot # screenline's number of the slant's pivot attr_accessor :cos_angle # cosinus of the slant's angle attr_accessor :sin_angle # sinus of the slant's angle attr_accessor :height_limit # horizon's line attr_accessor :distance_h # distance between the map's center and the vanishing point attr_accessor :slope_value # intermediate value attr_accessor :corrective_value # intermediate value attr_accessor :height # map's height (in pixel) #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- alias initialize_mode7_game_temp initialize def initialize initialize_mode7_game_temp self.pivot = 0 self.cos_angle = 0.0 self.sin_angle = 0.0 self.height_limit = 0 self.distance_h = 0 self.slope_value = 0.0 self.corrective_value = 0.0 self.height = 0 end end
Bugs e Conflitti NotiIo stesso non l ho ancora provato perche sono in inghilterra, se non funge, potete cancellare pure il topic
EDIT: OPPPS! hO FATTO UNA CAZ...A!!Lo aveva gia postato marigno!! Chiedo la cancellazione della discusasione.
-
Editato!
-
Credo di sì, cosa ti serve?
-
Ho deciso di aprire una bottega molto semplice, anche se purtroppo non potrò essere sempre presente...
Comunque le mie creazioni saranno:
-Chara civili e guerrieri (per xp)
-Faceset (per vx)
-Sfondi fantasy (da usare scome immagini o titoli)
EDIT: Nuove aggiunte:
-Musiche (mp3, wav,...)
-Pacchetto di risorse(facce, battler, chara non miei, in base a richiesta): 5 rens.
Per pacchetto intendo un insieme minimo di 10 risorse (es. battler rpgmakerxp predefiniti
disegnati in modo diverso) a secondo del tipo di richiesta (battler, chara, face,...)
Ogni cosa costerà 1 ren (penso che sia già troppo, contando la mia scarsa creatività)
Credo che potrò verificare le richieste una volta a settimana e di sicuro entro Sabato.
Grazie mille!! :rovatfl:
-
Ho messo il link su una discussione su risorse grafiche per xp.
Prova a vedere lì, ci sono anche le istruzioni!
-
D: Scusate, ma sulla recensione di rpgmakervx del forum c'è scritto che si possono inserire i video senza script, ma io non ho capito come si fa...
-
-
L'ho modificato in italiano!
-
Eccoti delle informazioni dal sito in inglese:
Piccola PresentazioneNet Rmxp Online è un pacchetto di script che vi permette di trasformare il vostro Rpg in un oRpg, ovvero un gioco online dove ogni giocatore potrà interagire con altri. Non abbiamo detto MmoRpg perchè con quelli si riferisce ad un gioco con migliaia di utenti, mentre cn NRmxp potete creare community abbastanza grandi. Ma come sempre, un gioco online che si rispetti, richiede Admin che siano capaci & scripter che migliorino sempre più il gioco per mantenerlo attivo.
E' semplice da usare?
Bhe, dovete conoscere almeno le basi dell'RGSS, e dovete essere in grado aprire o sostenere un server. Abbastanza semplice ^^
Chi l'ha creato?
Essendo basato su NetPlayPlus 1.6, sento il bisogno di mettere in primo luogo:
Goldenaura e Mr Mo, conosciuto anche come "Me"
Client: Sweet Vengeance
Server : Sweet Vengeance
Web Support : Sweet Vengeance
Screenshot:
Trovi qui gli screenshot: http://glowproductions.altervista.org/img.html
Alcune Fetures
- PVE
- PVP
- Npc & Eventi Globali
- Trade System *** Originale della NetPlay ***
- Multiple Private Chat System *** Originale della NetPlay ***
- PM (Email Style)
- Party
- Gilde
- Chat Globale/Mappa/Party/Gilde
E altre features che ora non mi vengono in mente...
Requisiti Fondamentali:
Microsoft Windows XP
1.5GHz Intel Pentium 4 o superiore
Almeno un Gb di Ram per giocare senza alcun problema o rallenti
Download:
Server: http://www.mediafire.com/?xnxmu9ndwbd
Client: http://www.mediafire.com/?yvtjtzetylh
Tutorial o Guide:
Saranno presto nella sezione Guide
Botta e Risposta:
D:Puoi aggiungere X funzione?
R:Certo, logicamente mantenendosi nei limiti!
D:Il Server crasha continuamente. Cosa faccio?
R:Cambia computer. Molto probabilmente è instabile. Vedete il Server di NRMXP è progettato per pc modesti, ma se avete un pc potente e lo riempiete di roba e usate 100mila programmi in una volta... Non posso farvi niente...
D:Posso continuare il tuo lavoro?
R:Solo dopo il mio consenso via PM.
D:Il Client è lento e crasha continuamente. Cosa faccio?
R:Cambia pc o aumenta le sue prestazioni.
D:Voglio donare un offerta per il tuo lavoro!
R:Grazie! Scrivetemi via PM e vi farò sapere tutto quello di cui avete bisogno ^^
Io non l'ho ancora provato xkè il computer si è fulminato, ma l'ha fatto un io compagno di classe,
che l'ha trovato sul sito che sono andato a vedere:
-
Battaglia automatica
Descrizione
Inserisce nei comandi di battaglia questa opzione(per vx)Autore
DargorAllegati
NessunoIstruzioni per l'uso
Incollare sopra main#====================================================================== ======== # ** Auto Battle #------------------------------------------------------------------------------ # © Dargor, 2008 # 13/05/08 # Version 1.2 #------------------------------------------------------------------------------ # VERSION HISTORY: # - 1.0 (24/03/08), Initial release # - 1.1 (13/05/08), Added auto-battle modes (Single Turn/Whole Battle) # - 1.2 (13/05/08), Added auto-battle cancelation (use SHIFT) #------------------------------------------------------------------------------ # INSTRUCTIONS: # 1) Paste the script above main # 2) To change an actor's auto battle option, use: # $game_actors[actor_id].auto_battle = true/false # 3) To enable/disable the auto battle option, useL # $game_system.auto_battle_disabled = true/false #============================================================================== # Vocabulary: Auto Battle Command Vocab::AutoBattle = 'Auto' #============================================================================== # ** Game_System #------------------------------------------------------------------------------ # This class handles system-related data. Also manages vehicles and BGM, etc. # The instance of this class is referenced by $game_system. #============================================================================== class Game_System #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :auto_battle_disabled attr_accessor :auto_battle_mode #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_system_auto_battle_initialize initialize #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize @auto_battle_disabled = false # Enable/Disable flag @auto_battle_mode = 0 # 0: Single Turn 1: Whole Battle dargor_vx_system_auto_battle_initialize end end #============================================================================== # ** Game_Temp #------------------------------------------------------------------------------ # This class handles temporary data that is not included with save data. # The instance of this class is referenced by $game_temp. #============================================================================== class Game_Temp #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :in_auto_battle # in-battle flag attr_accessor :auto_battle_canceled #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_temp_auto_battle_initialize initialize #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize @in_auto_battle = false @auto_battle_canceled = false dargor_vx_temp_auto_battle_initialize end end #============================================================================== # ** Game_Actor #------------------------------------------------------------------------------ # This class handles actors. It's used within the Game_Actors class # ($game_actors) and referenced by the Game_Party class ($game_party). #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :auto_battle #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_actor_auto_battle_setup setup #-------------------------------------------------------------------------- # * Setup # actor_id : actor ID #-------------------------------------------------------------------------- def setup(actor_id) actor = $data_actors[actor_id] @auto_battle = actor.auto_battle dargor_vx_actor_auto_battle_setup(actor_id) end end #============================================================================== # ** Scene_Battle #------------------------------------------------------------------------------ # This class performs battle screen processing. #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_battle_auto_battle_update_basic update_basic alias dargor_vx_battle_auto_battle_create_info_viewport create_info_viewport alias dargor_vx_battle_auto_battle_start_party_command_selection start_party_command_selection alias dargor_vx_battle_auto_battle_update_party_command_selection update_party_command_selection alias dargor_vx_battle_auto_battle_process_victory process_victory #-------------------------------------------------------------------------- # * Basic Update Processing # main : Call from main update method #-------------------------------------------------------------------------- def update_basic(main = false) if Input.trigger?(Input::SHIFT) $game_temp.in_auto_battle = false $game_temp.auto_battle_canceled = true end dargor_vx_battle_auto_battle_update_basic(main) end #-------------------------------------------------------------------------- # * Create Information Display Viewport #-------------------------------------------------------------------------- def create_info_viewport commands = $game_system.party_commands $game_system.add_party_command(commands.size-1, Vocab::AutoBattle) dargor_vx_battle_auto_battle_create_info_viewport index = commands.index(Vocab::AutoBattle) @party_command_window.draw_item(index, !$game_system.auto_battle_disabled) end #-------------------------------------------------------------------------- # * Start party command selection #-------------------------------------------------------------------------- def start_party_command_selection if $game_system.auto_battle_mode == 1 && $game_temp.in_auto_battle for actor in $game_party.members actor.make_action end start_main return end dargor_vx_battle_auto_battle_start_party_command_selection end #-------------------------------------------------------------------------- # * Update Party Command Selection #-------------------------------------------------------------------------- def update_party_command_selection dargor_vx_battle_auto_battle_update_party_command_selection if Input.trigger?(Input::C) case $game_system.party_commands[@party_command_window.index] when Vocab::AutoBattle # Auto Battle if $game_system.auto_battle_disabled Sound.play_buzzer return end if $game_system.auto_battle_mode == 1 $game_temp.in_auto_battle = true end for actor in $game_party.members actor.make_action end Sound.play_decision start_main end end end #-------------------------------------------------------------------------- # * Victory Processing #-------------------------------------------------------------------------- def process_victory $game_temp.in_auto_battle = false dargor_vx_battle_auto_battle_process_victory end endBugs e Conflitti Noti
N/AAltri Dettagli
Nessuno -
Skill Draw
Descrizione
Come in ff8, assimila le magieAutore
DargorAllegati
NessunoIstruzioni per l'uso
Inserire sopra main#====================================================================== ======== # ** Skill Draw (FFVIII) #------------------------------------------------------------------------------ # © Dargor, 2008 # 08/05/08 # Version 1.2 #------------------------------------------------------------------------------ # VERSION HISTORY: # - 1.0 (11/05/08), Initial release # - 1.1 (14/05/08), Bug fixed with consuming skill number # - 1.2 (14/05/08), Bug fixed with initial skill number #------------------------------------------------------------------------------ # INSTRUCTIONS: # 1) Paste the script above main # 2) Edit the Vocab variables # 2) Edit the constants in the Skill_Draw module #============================================================================== # Command name Vocab::CommandDraw = 'Draw' Vocab::CommandDrawStock = 'Stock' Vocab::CommandDrawCast = 'Cast' Vocab::UnknownSkill = '??????' Vocab::UseDraw = "%s uses #{Vocab::CommandDraw}!" Vocab::DrawGain = "%s draw %s %s!" Vocab::DrawFail = "%s's draw failed." module Skill_Draw # The Draw Animation Animation_id = 41 # Prevent from drawing specific enemy skills # SYNTAX: enemy_id => [skill_id, ...] Dont_Draw = { 1 => [2,3] } end #============================================================================== # ** Game_System #------------------------------------------------------------------------------ # This class handles system-related data. Also manages vehicles and BGM, etc. # The instance of this class is referenced by $game_system. #============================================================================== class Game_System #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :skill_drawned #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_draw_system_initialize initialize #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize dargor_vx_draw_system_initialize @skill_drawned = [] end end #============================================================================== # ** Game_BattleAction #------------------------------------------------------------------------------ # This class handles battle actions. This class is used within the # Game_Battler class. #============================================================================== class Game_BattleAction #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :draw_kind # draw kind (stock/cast) #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_draw_battle_action_clear clear alias dargor_vx_draw_battle_action_make_targets make_targets #-------------------------------------------------------------------------- # * Clear #-------------------------------------------------------------------------- def clear @draw_kind = -1 # The usual dargor_vx_draw_battle_action_clear end #-------------------------------------------------------------------------- # * Set Skill # skill_id : skill ID # draw_kind: draw kind (stock/cast) #-------------------------------------------------------------------------- def set_skill(skill_id, draw_kind = -1) @kind = 1 @skill_id = skill_id @draw_kind = draw_kind end #-------------------------------------------------------------------------- # * Draw Determination #-------------------------------------------------------------------------- def draw? return @kind == 1 && [0,1].include?(@draw_kind) end #-------------------------------------------------------------------------- # * Create Target Array #-------------------------------------------------------------------------- def make_targets targets = [] if draw? targets.push(opponents_unit.smooth_target(@target_index)) return targets end dargor_vx_draw_battle_action_make_targets end end #============================================================================== # ** Game_Battler #------------------------------------------------------------------------------ # This class deals with battlers. It's used as a superclass of the Game_Actor # and Game_Enemy classes. #============================================================================== class Game_Battler #-------------------------------------------------------------------------- # * Draw Success # skill : skill # number: number to draw #-------------------------------------------------------------------------- def draw_success?(skill, number) return false unless self.is_a?(Game_Actor) return false if number == 0 level_factor = (self.level / 10) / 2 random = [10-level_factor, 0].max success = (self.level / 10) + rand(random) return success >= number end end #============================================================================== # ** Game_Actor #------------------------------------------------------------------------------ # This class handles actors. It's used within the Game_Actors class # ($game_actors) and referenced by the Game_Party class ($game_party). #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :skills_number #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_draw_actor_skill_can_use? skill_can_use? alias dargor_vx_draw_actor_setup setup #-------------------------------------------------------------------------- # * Setup # actor_id : actor ID #-------------------------------------------------------------------------- def setup(actor_id) @skills_number = [] dargor_vx_draw_actor_setup(actor_id) for i in self.class.learnings @skills_number[i.skill_id] == 1 if i.level <= @level end # Add battle commands case @actor_id when 1,2,3,4,5,6,7,8 # Add 'Draw' to actor 1 add_command(1, Vocab::CommandDraw) end end #-------------------------------------------------------------------------- # * Learn Skill # skill_id : skill ID #-------------------------------------------------------------------------- def learn_skill(skill_id) $game_system.skill_drawned << skill_id unless skill_learn?($data_skills[skill_id]) @skills.push(skill_id) @skills.sort! end end #-------------------------------------------------------------------------- # * Get Number of Items Possessed # item : item #-------------------------------------------------------------------------- def skill_number(skill) number = @skills_number[skill.id] return number == nil ? 0 : number end #-------------------------------------------------------------------------- # * Determine Usable Skills # skill : skill #-------------------------------------------------------------------------- def skill_can_use?(skill) return false unless skill_number(skill) > 0 dargor_vx_draw_actor_skill_can_use?(skill) end #-------------------------------------------------------------------------- # * Gain Items (or lose) # item : Item # n : Number # include_equip : Include equipped items #-------------------------------------------------------------------------- def gain_skill(skill, n) $game_system.skill_drawned << skill.id number = skill_number(skill) @skills_number[skill.id] = [[number + n, 0].max, 99].min n += number end #-------------------------------------------------------------------------- # * Lose Items # item : Item # n : Number # include_equip : Include equipped items #-------------------------------------------------------------------------- def lose_skill(skill, n) gain_skill(skill, -n) end end #============================================================================== # ** Game_Enemy #------------------------------------------------------------------------------ # This class handles enemy characters. It's used within the Game_Troop class # ($game_troop). #============================================================================== class Game_Enemy < Game_Battler #-------------------------------------------------------------------------- # * Skills #-------------------------------------------------------------------------- def skills result = [] for action in enemy.actions next unless action.skill? result << $data_skills[action.skill_id] end return result end end #============================================================================== # ** Window_Skill #------------------------------------------------------------------------------ # This window displays a list of usable skills on the skill screen, etc. #============================================================================== class Window_Skill < Window_Selectable #-------------------------------------------------------------------------- # * Draw Item # index : item number #-------------------------------------------------------------------------- def draw_item(index) rect = item_rect(index) self.contents.clear_rect(rect) skill = @data[index] if skill != nil rect.width -= 4 enabled = @actor.skill_can_use?(skill) draw_item_name(skill, rect.x, rect.y, enabled) self.contents.draw_text(rect, @actor.calc_mp_cost(skill), 2) # Draw skill number rect.x -= 24 self.contents.draw_text(rect, ":", 2) rect.x -= 12 skill_number = @actor.skill_number(skill) if enabled self.contents.font.color = text_color(3) end self.contents.draw_text(rect, skill_number.to_s, 2) end end end #============================================================================== # ** Window_Skill #------------------------------------------------------------------------------ # This window displays a list of usable skills on the skill screen, etc. #============================================================================== class Window_EnemySkill < Window_Selectable #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :enemy #-------------------------------------------------------------------------- # * Object Initialization # x : window x-coordinate # y : window y-coordinate # width : window width # height : window height # actor : actor #-------------------------------------------------------------------------- def initialize(x, y, width, height, enemy) super(x, y, width, height) @enemy = enemy @column_max = 2 self.index = 0 refresh end #-------------------------------------------------------------------------- # * Skill #-------------------------------------------------------------------------- def skill return @data[self.index] end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh @data = [] for skill in @enemy.skills unless Skill_Draw::Dont_Draw[@enemy.id].nil? next if Skill_Draw::Dont_Draw[@enemy.id].include?(skill.id) end @data.push(skill) end @item_max = @data.size create_contents for i in 0...@item_max draw_item(i) end end #-------------------------------------------------------------------------- # * Draw Item # index : item number #-------------------------------------------------------------------------- def draw_item(index) rect = item_rect(index) self.contents.clear_rect(rect) skill = @data[index] if skill != nil rect.width -= 4 draw_item_name(skill, rect.x, rect.y, true) end end #-------------------------------------------------------------------------- # * Draw Item Name # item : Item (skill, weapon, armor are also possible) # x : draw spot x-coordinate # y : draw spot y-coordinate # enabled : Enabled flag. When false, draw semi-transparently. #-------------------------------------------------------------------------- def draw_item_name(item, x, y, enabled = true) if item != nil draw_icon(item.icon_index, x, y, enabled) self.contents.font.color = normal_color self.contents.font.color.alpha = enabled ? 255 : 128 if item.is_a?(RPG::Skill) && !$game_system.skill_drawned.include?(item.id) self.contents.draw_text(x + 24, y, 172, WLH, Vocab::UnknownSkill) else self.contents.draw_text(x + 24, y, 172, WLH, item.name) end end end #-------------------------------------------------------------------------- # * Frame Update #-------------------------------------------------------------------------- def update super end #-------------------------------------------------------------------------- # * Update Help Text #-------------------------------------------------------------------------- def update_help if $game_system.skill_drawned.include?(skill.id) @help_window.set_text(skill == nil ? "" : skill.description) else @help_window.set_text(skill == nil ? "" : Vocab::UnknownSkill) end end end #============================================================================== # ** Scene_Battle #------------------------------------------------------------------------------ # This class performs battle screen processing. #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias dargor_vx_draw_battle_update update alias dargor_vx_draw_update_actor_command_selection update_actor_command_selection alias dargor_vx_draw_execute_action execute_action alias dargor_vx_draw_execute_action_skill execute_action_skill alias dargor_vx_draw_update_target_enemy_selection update_target_enemy_selection #-------------------------------------------------------------------------- # * Frame Update #-------------------------------------------------------------------------- def update unless @enemy_skill_window != nil or @draw_command_window != nil dargor_vx_draw_battle_update else super update_basic(true) update_info_viewport # Update information viewport if $game_message.visible @info_viewport.visible = false @message_window.visible = true end unless $game_message.visible # Unless displaying a message return if judge_win_loss # Determine win/loss results update_scene_change if @enemy_skill_window.active update_enemy_skill_selection # Select party changer command elsif @draw_command_window.active update_draw_command_selection # Select party changer command end end end end #-------------------------------------------------------------------------- # * Update Actor Command Selection #-------------------------------------------------------------------------- def update_actor_command_selection dargor_vx_draw_update_actor_command_selection if Input.trigger?(Input::C) case @actor_command_window.commands[@actor_command_window.index] when Vocab::CommandDraw Sound.play_decision start_target_enemy_selection end end end #-------------------------------------------------------------------------- # * Update Target Enemy Selection #-------------------------------------------------------------------------- def update_target_enemy_selection if Input.trigger?(Input::C) && @actor_command_window.selection == Vocab::CommandDraw Sound.play_decision Sound.play_decision @active_battler.action.target_index = @target_enemy_window.enemy.index start_draw_command_selection end_target_enemy_selection end_skill_selection end_item_selection return end dargor_vx_draw_update_target_enemy_selection end #-------------------------------------------------------------------------- # * Start Draw Command Selection #-------------------------------------------------------------------------- def start_draw_command_selection enemy = @target_enemy_window.enemy @help_window = Window_Help.new @help_window.y = 56 @enemy_skill_window = Window_EnemySkill.new(0, 112, 544, 176, enemy) @enemy_skill_window.help_window = @help_window @enemy_skill_window.active = false s1 = Vocab::CommandDrawStock s2 = Vocab::CommandDrawCast @draw_command_window = Window_Command.new(544, [s1,s2], 2) end #-------------------------------------------------------------------------- # * Update Draw Command Selection #-------------------------------------------------------------------------- def update_draw_command_selection @draw_command_window.update @actor_command_window.active = false if Input.trigger?(Input::B) end_draw_command_selection return end if Input.trigger?(Input::C) @enemy_skill_window.active = true return end end #-------------------------------------------------------------------------- # * End Draw Command Selection #-------------------------------------------------------------------------- def end_draw_command_selection if @enemy_skill_window != nil @enemy_skill_window.dispose @enemy_skill_window = nil @draw_command_window.dispose @draw_command_window = nil @help_window.dispose @help_window = nil end @actor_command_window.active = true end #-------------------------------------------------------------------------- # * Update Enemy Skill Selection #-------------------------------------------------------------------------- def update_enemy_skill_selection @help_window.update @enemy_skill_window.update @actor_command_window.active = false if Input.trigger?(Input::B) @draw_command_window.active = true @enemy_skill_window.active = false return end if Input.trigger?(Input::C) case @draw_command_window.selection when Vocab::CommandDrawStock # Play decision SE Sound.play_decision @active_battler.action.set_skill(@enemy_skill_window.skill.id, 0) # Force the action to be executed @active_battler.action.forcing = true # End draw selection end_draw_command_selection # Switch to next actor next_actor when Vocab::CommandDrawCast Sound.play_decision # Prepare to cast a drawned skill @active_battler.action.set_skill(@enemy_skill_window.skill.id, 1) # Force the action to be executed @active_battler.action.forcing = true @active_battler.action.target_index = @enemy_skill_window.enemy.index # End draw selection end_draw_command_selection # Switch to next actor next_actor end end end #-------------------------------------------------------------------------- # * Execute Battle Actions #-------------------------------------------------------------------------- def execute_action if @active_battler.action.draw? case @active_battler.action.draw_kind when 0 # Stock execute_action_draw_stock return when 1 # Cast execute_action_draw_cast return end end # The usual dargor_vx_draw_execute_action end #-------------------------------------------------------------------------- # * Execute Battle Action: Skill #-------------------------------------------------------------------------- def execute_action_skill skill = @active_battler.action.skill # Remove 1 skill number if @active_battler.is_a?(Game_Actor)# && #!@active_battler.action.draw_kind == 0 @active_battler.lose_skill(skill, 1) end # The usual dargor_vx_draw_execute_action_skill end #-------------------------------------------------------------------------- # * Execute Battle Action: Draw Stock #-------------------------------------------------------------------------- def execute_action_draw_stock text = sprintf(Vocab::UseDraw, @active_battler.name) @message_window.add_instant_text(text) targets = @active_battler.action.make_targets display_animation(targets, Skill_Draw::Animation_id) # Add skill number skill = @active_battler.action.skill gain = rand(9) if @active_battler.draw_success?(skill, gain) if @active_battler.is_a?(Game_Actor) @active_battler.gain_skill(skill, gain) @active_battler.learn_skill(skill.id) end name = skill.name name += 's' if gain > 1 text = sprintf(Vocab::DrawGain, @active_battler.name, gain, name) @message_window.add_instant_text(text) wait(60) else text = sprintf(Vocab::DrawFail, @active_battler.name) @message_window.add_instant_text(text) wait(60) end end #-------------------------------------------------------------------------- # * Execute Battle Action: Draw Cast #-------------------------------------------------------------------------- def execute_action_draw_cast # Add skill to known skills skill = @active_battler.action.skill $game_system.skill_drawned << skill.id # Cast the skill execute_action_skill end endBugs e Conflitti Noti
N/AAltri Dettagli
Preso da -
Come già detto, usero questa discussione per metterci i miei link.
Ho trovato un gioco di rpgmaker, solo che si gioca online, con altri giocatori.
Ecco qui il link per il scaricare il gioco:
Ed ecco alcuni screenshot:
Il gioco è in italiano e si chiama "Net Rmxp Online".
ps:(magari l'hanno già messo sul forum...)
Ecco qui invece un gioco mooolto interessante su megaupload:
C'è anche un programma che a quanto pare contiene un sacco di script, alcuni nuovi (se ho ben capito):
Qui ho messo uno script abs per xp, il migliore mai visto!!
-
Spero che non dispiaccia a nessuno se uso questa discussione per metterci sopra le ie cose.
(tipo link, risorse grafiche,...)
-
Io ho Vista e non so se centra molto.
Nel mio gioco ho messo dopo Nuova partita un video.
Cioè play BGM: il video che era nella cartella.
Si apre una finestra con scritto "Active movie (window)".
Ma poi il video parte anche sugli altri pc?
-
Un utilissimo programma per sfondi 3d.
Utilizzato personalmente.
Ho trovato anche questo sito, ma non so se c'è qualcosa di utile.
Sito giapponese della enterbrain!
Questo invece è per creare tilesets:
Questo per i characters, ma penso che sia già stato messo.
Qui due siti per fare le facce:
oppure prendete il tool:
Ho allegato anche un pacchetto speciale, con tutti gli rgss. Per non avere problemi di copatibilità.
Dovete copiarli nella cartella del gioco che volete fare e anche in c:Windows.
Ecco qui il link su megaupload:
Spero che sia utile!!!
-
Molto utile complimenti!
-
Se vuoi rpg prendi Final Fantasy revenant wings.
-
ALLORA? A nessuno interessa?
-
Il problema è che non so come fare se uno decide di usare il pedone (ad es.) per mangiare.
Il pedone deve procedere in diagonale solo se c'è un'altra pedina che possa essere mangiata
e tral'altro devo stare attento che il re non cada sotto scacco.
Per questo non riesco a farlo a eventi.
-
Nome Script
Descrizione
Permette di impostare il rigenero di vita e mana (o tutti e due) in difesa
Autore
Ojiro; tradotto da me
Allegati
Nessuno
Istruzioni per l'uso
ICreate una classe su Main e chiamatela "Défense Régénération" incollate poi il codice:
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ #_/ Rigenerazione in difesa: Translated by Ojiro e in italiano da payam #_/------------------------------------------ ---------------------------------- #_/ Rigenerazione di un personaggio che si difende #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ class Scene_Battle # HP Regen % RECOVER_HP_RATE = 5 # SP Regen % RECOVER_SP_RATE = 0 end #============================================ ====================== # ¦ Scene_Battle (4) #-------------------------------------------- ---------------------------------- # E' la scena che segue dopo l'attacco #============================================ ====================== class Scene_Battle #-------------------------------------------- ------------------------------ # Compila i risultati basilari di combattimento #-------------------------------------------- ------------------------------ alias make_basic_action_result_KGC_GuardRecover make_basic_action_result def make_basic_action_result # Esegue il processo di origine make_basic_action_result_KGC_GuardRecover # Avviene quando si sceglie un'altr'azione. Cioè non la difesa. return if @active_battler.current_action.basic != 1 # Segue il calcolo di rigenerazione recover_hp = @active_battler.maxhp * RECOVER_HP_RATE / 100 recover_sp = @active_battler.maxsp * RECOVER_SP_RATE / 100 if recover_hp < 0 @active_battler.damage = -recover_hp end if recover_sp < 0 @active_battler.damage = "#{$data_system.words.sp}+ #{recover_sp}" end @active_battler.hp += recover_hp @active_battler.sp += recover_sp # Indique la valeur de regénération @target_battlers.push(@active_battler) end end
Bugs e Conflitti NotiN/A
Altri Dettagli
Per impostare il numero di HP ed MP da recuperare modificare queste 2 stringhe:
class Scene_Battle # HP Regen % RECOVER_HP_RATE = 5 # SP Regen % RECOVER_SP_RATE = 0 end
-
Sì, va bene.
Ma il problema è che non so scriptare!
-
Mi servirebbe uno script che appena si seleziona il pedone (o la regina,...) esca fuori un riquadro con tre opzioni:
Muovi
Mangia
Annulla
Usando mangia, se è possibile selezionare l'avversario, avviene una battaglia.
Io non sono capace di fare scripts, specie di questo genere in cui bisogna dare ogni mossa possibile ad ogni scacco.
C'è qualcuno disposto a farlo?
*Rigenerazione su mappa
in Scripts RGSS (XP)
Posted
On map regeneration
Descrizione
L`eroe rigenera hp, mp camminando sulla mappa (rigenerazione differente per eroe)
Autore
Caldaron
Istruzioni per l'uso
Inserite sopra main:
Script:
Inserite sopra main:
Bugs e Conflitti Noti
N/A