Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[XP] Recopilación de scripts 'no publicados' de Wecoc

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP] Recopilación de scripts 'no publicados' de Wecoc

Mensaje por Wecoc el 2018-10-29, 20:45

Tengo muchos scripts en la sección de Scripts, pero también hay algunos que no he publicado aquí aún, y por eso decidí hacer este topic. Se trata de scripts que publiqué en otros foros y también esos que hice para montar algún engine.

Como sabéis he publicado algunos engines, y en ellos suelo incluir también scripts. Hay dos casos, esos scripts muy específicos para el sistema, y luego algunos scripts más genéricos que pueden ser útiles sin el sistema y es en los que me centraré.

Primero de todo enlazo los que publiqué en otros foros o secciones del foro.

Recopilación de scripts:
Enemy Gold & Exp Drop Variance
Añadir variancia a la experiencia y dinero dropeados en batalla

Desbloqueable - Cambiar título con variable + Obtener variable máxima
Obtener el máximo de una variable a lo largo de todas las partidas guardadas

2K Get Event IDs
Por tener los eventos que se encuentran en una coordenada concreta

2K Set Encounter Steps + Versión "Lite"
Cambiar por evento el número de pasos por encuentro enemigo

Replace Tile AddOn
Cambiar un tile por otro a lo largo del mapa

Eventos de suelo y eventos bajo suelo
Poner eventos bajo el personaje

Remove skill 'Learnings' and 'Not Learnings'
Retirar al héroe todas las skills que no sean learnings de su clase actual

2k Change Tileset
Cambiar el tileset del mapa por otro dinámicamente

2k Set Escape Location
Posición en la que apareces cuando escapas de batalla

Data SE Overwrite
Cambiar los sonidos del sistema a medio juego

Game Event Passable Touch
Impedir interactuar con eventos si están en situación no pasable desde el jugador

XP Interpreter Edit for Fiber
Adaptación del Interpreter a la clase interna Fiber [Descartado]

Weapon Auto-states
Armas con opción auto-estado como el de los protectores

Battler Hue Spin + Panorama/Fog Hue Spin
El tono de battler, panorama o fog cambia constantemente

Wecoc's Event Layer Script Advanced (WELSA)
Más capas de prioridad para eventos, definibles con llamadas de script

Critical Multiplier by Actor/Enemy ID
Cambiar el multiplicador del efecto Crítico según la ID del target

Parámetros plus para ATK, PDEF, MDEF y EVA
Añade parámetro "plus" a los parámetros base que no lo tienen, para poder controlarlos in-game

Modificar el SP cost de habilidades
Multiplicadores para el coste de SP según el actor, enemigo o estado alterado.

Máximo individual para items
Máximo individual para items mostrado como mini-icono al lado del icono principal del item

Multiple Animations
Permite más de una animación a la vez a los sprites, además arreglado para integrar animaciones de distintas alturas

Experience Array
Permite definir la curva de experiencia con una array

Battle Helpers
Poner ayudantes/invocaciones temporales en batalla

Array de terrenos
Comprobar el terreno de cada capa individualmente

Tactic teleport
Teletransporte aleatorio por el mapa (con rango definido si es preciso)

Mostar pop-up de daño en mapa
Atajos para mostrar daño en mapa

Character Offset Script
Permite mover las coordenadas de los charas por píxel en un momento determinado

Basic Balloon Script
Añade globos de emociones encima del chara

Create Event Basic Support
Script básico para crear eventos nuevos mediante llamada de script

Bomb Script
Script de lanzar bomba en batalla de modo que afecta al target y a los battlers más cercanos

Map Step Counter
Distintos contadores de pasos según el mapa

Window Hidden Class + Blind Add-On + Adaptaciones
Reescritura de la clase Window para soportar otros tipos de Windowskin, con muchos añadidos

Message Map Freeze + Debug Speed Up
Controlar el tiempo: pararlo cuando hay un mensaje activo o bien acelerarlo en modo Debug al pulsar una tecla

Music in Menu
Poner una música específica para cuando estás en el menú

Passable 'Unpass' Edits
Control de pasabilidad con mapa, eventos y jugador separadamente.

Shop Sell Add-on: Sellable items
Definir qué items se pueden vender

Diablo-style Dynamic Maps
Construir mapa por bloques de modo que en cada partida nueva tiene variaciones. Soporte Game_Maps útil para otros scripts.

Wecoc's Rand Event Position
Sistema de Pathfinding simple. Colocación de eventos en el mapa al azar, pero siempre en posiciones accesibles (+ versión Areas)

Transition EX
Transiciones de pantalla con punto central, tanto eventos como coordenadas específicas

Pronto pondré aquí los scripts útiles de los engines, con código entero e instrucciones para hacerlo más fácil.
avatar
Wecoc
Administrador
Administrador



Créditos 12310

Gracias : 654

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Recopilación de scripts 'no publicados' de Wecoc

Mensaje por Wecoc el 2018-11-07, 19:14

La lista ya está terminada, parece que ya están todos los que habían quedado apartados. Ahora iré a por los scripts de sistema, usados en engines. Nótese que descarto esos scripts que son específicos solo para un determinado engine.

1. Simple Clone Events
Usado en: Engine de la escolopendra, compatible con todo

Este script permite clonar eventos simples, en el mismo mapa (se clona justo al lado del original, por defecto).
El evento clonado actúa exactamente como el original, además tiene una variable llamada @clone_id con la que puedes saber de qué evento original viene o bien si en definitiva tiene clones. Al salir del mapa y volver a entrar los clones desaparecen.

Código:
#==============================================================================
# ** [XP] Simple Clone Events
#------------------------------------------------------------------------------
# Autor: Wecoc (no requiere créditos)
#------------------------------------------------------------------------------
# Sistema de clonación de eventos compatible con prácticamente todo
# Crea un nuevo evento con el mismo contenido que el principal
#==============================================================================

#==============================================================================
# ** Game_Event
#==============================================================================

class Game_Event < Game_Character
  attr_accessor :clone_id, :event
  attr_reader :direction_fix
  alias clone_event_ini initialize unless $@
  def initialize(*args)
    clone_event_ini(*args)
    # Por defecto la variable @clone_id no se usa así que vale 0
    @clone_id = 0
  end
end

#==============================================================================
# ** Interpreter
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # * Clonar evento
  #--------------------------------------------------------------------------
  def clone_event
    # Calcular posición de clonación. Si no es posible clonarlo cerca, se
    # aborta la clonación
    event = $game_map.events[@event_id]
    # Si usas el script Drop items in map el cálculo al tile más cercano
    # donde aparecerá el monstruo es algo mejor, aún así es opcional
    if event.respond_to?(:nearest_passable)
      nearest = event.nearest_passable(event.x, event.y)
    else
      if event.passable?(event.x, event.y + 1, 0)
        nearest = [event.x, event.y + 1]
      elsif event.passable?(event.x - 1, event.y, 0)
        nearest = [event.x - 1, event.y]
      elsif event.passable?(event.x + 1, event.y, 0)
        nearest = [event.x + 1, event.y]
      elsif event.passable?(event.x, event.y - 1, 0)
        nearest = [event.x, event.y - 1]
      else
        nearest = [nil, nil]
      end
    end
    return if nearest == [nil, nil]
    # Una vez comprobado que es posible se aplica la clonación del evento
    event = $game_map.events[@event_id].clone
    event.event = event.event.clone
    if $game_map.events[@event_id].clone_id == 0
      $game_map.events[@event_id].clone_id = @event_id
    end
    event.clone_id = $game_map.events[@event_id].clone_id
    new_id = $game_map.events.keys.max + 1
    event.instance_eval("@id = #{new_id}; @locked = false")
    event.event.id = new_id
    $game_map.events[new_id] = event
    event.moveto(nearest[0], nearest[1])
    event.turn_toward_player unless event.direction_fix
    # También hay que añadir el sprite en Spriteset_Map
    if $scene.is_a?(Scene_Map)
      spriteset = $scene.instance_eval("@spriteset")
      sprites = spriteset.instance_eval("
        sprite = Sprite_Character.new(@viewport1, $game_map.events[#{new_id}])
        @character_sprites.unshift(sprite)
      ")
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Mostrar efecto 'Muerte' [Demo]
  #--------------------------------------------------------------------------
  def collapse_event
    if $scene.is_a?(Scene_Map)
      spriteset = $scene.instance_eval("@spriteset")
      sprites = spriteset.instance_eval("@character_sprites")
      s = sprites.select {|sprite| sprite.character.id == @event_id}[0]
      s.color.set(255, 64, 64, 255)
      s.blend_type = 1
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Obtener eventos clones del actual
  #--------------------------------------------------------------------------
  def get_clones
    clone_id = $game_map.events[@event_id].clone_id
    return [] if clone_id == 0
    return $game_map.events.values.select{|event| event.clone_id == clone_id}
  end
  #--------------------------------------------------------------------------
  # * Quitar evento
  #--------------------------------------------------------------------------
  def remove_event
    $game_map.events.delete(@event_id)
    for key in ["A", "B", "C", "D"]
      $game_self_switches[[@map_id, @event_id, key]] = false
    end
    if $scene.is_a?(Scene_Map)
      spriteset = $scene.instance_eval("@spriteset")
      sprites = spriteset.instance_eval("@character_sprites")
      sprites.reject! {|sprite| sprite.character.id == @event_id}
    end
    clear
    return true
  end
end

Llamadas de script:
clone_event - Clona el evento actual
get_clones - Obtener los clones del evento actual (incluído él mismo)
Nota: Si get_clones.size es mayor que 0 es que tiene clones o es un clon, mientras que si vale 0 no hay clones de ese evento
remove_event - Borrar el evento actual de la lista de eventos
$game_map.events[ID].clone_id - Cambiando ID por la id de evento, obtiene la ID del evento original, o bien 0 si no es una copia

2. Map Ranges Check
Usado en: Engine del arbusto lloroso, compatible con todo

Comprueba si un evento está saliendo en screen o si queda fuera de pantalla.

Código:
#==============================================================================
# ** [XP] Map Ranges Check
#==============================================================================

class Game_Character
  def in_screen?(margin=0)
    return $game_map.in_screen?(@x, @y, margin)
  end
end

class Game_Map
  def in_screen?(x, y, margin=0)
    x *= 128 ; y *= 128 ; margin *= 4
    map_sx = @display_x - margin
    map_sy = @display_y - margin
    map_ex = map_sx + 20 * 128 + margin * 2
    map_ey = map_sy + 15 * 128 + margin * 2
    return x.between?(map_sx, map_ex) && y.between?(map_sy, map_ey)
  end
end

class Game_Event
  def front_quadrant?
    dx = $game_player.x - @x
    dy = $game_player.y - @y
    return false if $game_player.direction == 2 && dy > 0
    return false if $game_player.direction == 4 && dx < 0
    return false if $game_player.direction == 6 && dx > 0
    return false if $game_player.direction == 8 && dy < 0
    return true
  end
  
  def back_quadrant?
    dx = $game_player.x - @x
    dy = $game_player.y - @y
    return false if $game_player.direction == 2 && dy < 0
    return false if $game_player.direction == 4 && dx > 0
    return false if $game_player.direction == 6 && dx < 0
    return false if $game_player.direction == 8 && dy > 0
    return true
  end
end

Llamadas de script:
$game_map.in_screen?(X, Y) - Cambiando X e Y por coordenadas, comprueba si estas ahora son visibles en pantalla
$game_map.events[ID].in_screen? - Comprueba si el evento con id ID es visible en pantalla
Nota: En ambos se puede añadir otro argumento "margin", que por defecto es 0, sería el margen extra para considerarlo fuera de pantalla
$game_map.events[ID].front_quadrant? - Comprueba si el evento queda en el cuadrante de pantalla de delante del personaje
$game_map.events[ID].back_quadrant? - Comprueba si el evento queda en el cuadrante de pantalla de detrás del personaje

3. Platform System
Usado en: Engine de plataformas, compatible con todo

Este script permite dibujar tiles extra al mapa de modo similar al EMSTA, pero de modo más rudimentario y para casos más concretos.
Eso sí, tiene atajos para obtener tiles de un mapa concreto y dibujarlos en el mapa actual, lo cual lo hace más cómodo de usar en algunos casos.
Además, los nuevos tiles son agrupados en grupos distintos cada vez que los obtienes del otro mapa, y luego puedes obtener fácilmente sus tiles y aplicarles cambios. En el ejemplo de la demo se mueven arriba y abajo al pulsar una palanca.

Código:
#==============================================================================
# ** [XP] Platform System
#------------------------------------------------------------------------------
#  Author: Wecoc (no credits required)
#==============================================================================

class Game_Map
  attr_reader :extra_tiles, :map_clusters
  alias extra_s_setup setup unless $@
  def setup(map_id)
    extra_s_setup(map_id)
    @extra_tiles = []
    @map_clusters = []
  end
  
  def draw_extra_tile(x, y, tile_id)
    @extra_tiles.push([x, y, tile_id])
  end
  
  def set_map_cluster(x, y, width, height, rx, ry, map_id)
    cluster = []
    map = load_data(sprintf("Data/Map%03d.rxdata", map_id))
    for iy in 0...height
      for ix in 0...width
        for layer in 0..2
          tile_id = map.data[rx + ix, ry + iy, layer]
          draw_extra_tile(x + ix, y + iy, tile_id)
          cluster.push(@extra_tiles.size - 1)
        end
      end
    end
    @map_clusters.push(cluster)
  end
  
  def refresh_clusters
    @extra_tiles = []
    @map_clusters = []
  end
end

class Spriteset_Map
  attr_reader :extra_sprites
  alias extra_s_ini initialize unless $@
  def initialize
    @extra_tiles = []
    @extra_sprites = []
    extra_s_ini
  end
  
  alias extra_s_dis dispose unless $@
  def dispose
    for sprite in @extra_sprites
      sprite.bitmap.dispose
      sprite.dispose
    end
    @extra_sprites = []
    extra_s_dis
  end
  
  alias extra_s_upd update unless $@
  def update
    if @extra_tiles != $game_map.extra_tiles
      @extra_tiles = $game_map.extra_tiles
      for sprite in @extra_sprites
        sprite.dispose
      end
      @extra_sprites = []
      for i in 0...@extra_tiles.size
        x = @extra_tiles[i][0]
        y = @extra_tiles[i][1]
        tile_id = @extra_tiles[i][2]
        priority = $game_map.priorities[tile_id]
        sprite = Sprite.new(@viewport1)
        sprite.x = x * 32
        sprite.y = y * 32
        sprite.z = 32 + y * 32 + priority * 32
        sprite.bitmap = Bitmap.new(32, 32)
        draw_tile(sprite, tile_id)
        @extra_sprites.push(sprite)
      end
    end
    extra_s_upd
    for sprite in @extra_sprites
      sprite.update
      sprite.ox = $game_map.display_x / 4
      sprite.oy = $game_map.display_y / 4
    end
  end
  
  def draw_tile(sprite, tile_id)
    sprite.bitmap.clear
    if tile_id >= 384
      tile_id -= 384
      tileset = RPG::Cache.tileset($game_map.tileset_name)
      tx = (tile_id % 8) * 32
      ty = (tile_id.to_f / 8).floor * 32
      sprite.bitmap.blt(0, 0, tileset, Rect.new(tx, ty, 32, 32))
    end
  end
end

class Interpreter
  def get_cluster_sprites(id)
    spriteset = $scene.instance_eval("@spriteset")
    return if spriteset.nil?
    sprites = spriteset.extra_sprites
    result = []
    cluster = $game_map.map_clusters[id]
    for i in cluster
      result.push(sprites[i])
    end
    return result
  end
  
  def update_spriteset
    spriteset = $scene.instance_eval("@spriteset")
    return if spriteset.nil?
    spriteset.update
  end
end

Llamadas de script:
$game_map.set_map_cluster(X, Y, ANCHO, ALTO, RX, RY, ID mapa) - Crea un nuevo cluster de tiles
X, Y - Coordenadas en las que se dibujarán los tiles
ANCHO, ALTO - el número de tiles horizontal y vertical que se usan para cargar el cluster
RX, RY - Coordenadas de referencia, es decir de donde se sacan los tiles del mapa de donde se cargan
ID mapa - ID del mapa donde se cargan los tiles
update_spriteset - Una vez cargados los clusters necesarios para el mapa, los muestra bien en el spriteset
@cluster_sprites = get_cluster_sprites(ID) - Obtiene los sprites de un cluster concreto, para poder modificarles propiedades uno a uno.

4. Picture Event Chaser
Usado en: Flecha que indica proximidad de encuentro enemigo, compatible con todo

No sé si os ha pasado alguna vez que intentáis que una picure siga las coordenadas de pantalla del personaje o evento a tiempo real pero notáis que al moverse hay una cierta descompensación. Este script soluciona eso de modo fácil. El script usado en la demo es un poco distinto al posteado aquí, lo he cambiado para que sea más genérico.

Código:
#==============================================================================
# ** [XP] Picture Event Chaser
#------------------------------------------------------------------------------
# Autor: Wecoc (no requiere créditos)
#==============================================================================

module Picture_Chaser
  # ID interruptor => [Nº picture, ID evento a seguir (-1 si es el player)]
  CONFIG = {1 => [1, -1]}
end

class Spriteset_Map
  alias picture_chaser_upd update unless $@
  def update
    update_picture_position
    picture_chaser_upd
  end
  def update_picture_position
    #--------------------------------------------------------------------------
    # Comprobación: SwitchID
    for k in Picture_Chaser::CONFIG.keys
      if $game_switches[k] == true
        picture_id, event_id = *Picture_Chaser::CONFIG[k]
        if event_id == -1
          e = "$game_player"
        else
          e = "$game_map.events[#{event_id}]"
        end
        picture = $game_screen.pictures[picture_id]
        picture.instance_eval("@x = #{e}.screen_x; @y = #{e}.screen_y")
      end
    end
  end
end

No hay llamadas de script pero sí configuración. Hay un hash en el que defines ID interruptor => [Número picture, ID evento]
Por ejemplo {1 => [2, 3]} significaría que cuando el interruptor 1 está activado la picture 2 sigue al evento 3. Se puede poner -1 al evento para que siga al personaje. Además se pueden poner varios seguidos de una coma, ejemplo: {1 => [2, 3], 4 => [5, -1]}

5. Batalla por planos - Game Picture
Usado en: Batalla por planos, reescribe :initialize, :dispose y :update de Sprite_Picture

Este script es viejo y simple (no tiene ni nombre) pero bastante útil. Añade atajos para dada una picture obtener su sprite, cambiar su nombre directamente y aplicarle un flash similar a los flash de pantalla.

Código:
class Game_Picture
  attr_accessor :name
  attr_accessor :flash_color
  
  alias batallaplanos_initialize initialize unless $@
  def initialize(viewport)
    batallaplanos_initialize(viewport)
    @flash_color = Color.new(0, 0, 0, 0)
    @flash_duration = 0
  end
  
  def sprite
    return $scene.spriteset.picture_sprites[@number] if $scene.is_a?(Scene_Map)
  end
    
  def flash(color, duration)
    @flash_color = color.clone
    @flash_duration = duration
  end
  
  alias batallaplanos_update update unless $@
  def update
    batallaplanos_update
    if @flash_duration >= 1
      d = @flash_duration
      @flash_color.alpha = @flash_color.alpha * (d - 1) / d
      @flash_duration -= 1
    end
  end
end

class Sprite_Picture < RPG::Sprite
  def initialize(viewport, picture)
    super(viewport)
    @picture = picture
    update
  end
  def dispose
    self.bitmap.dispose if self.bitmap != nil
    super
  end
  def update
    super
    if @picture_name != @picture.name
      @picture_name = @picture.name
      self.bitmap = RPG::Cache.picture(@picture_name) if @picture_name != ""
    end
    if @picture_name == ""
      self.visible = false
      return
    end
    self.visible = true
    if @picture.origin == 0
      self.ox = 0
      self.oy = 0
    else
      self.ox = self.bitmap.width / 2
      self.oy = self.bitmap.height / 2
    end
    self.x = @picture.x
    self.y = @picture.y
    self.z = @picture.number
    self.zoom_x = @picture.zoom_x / 100.0
    self.zoom_y = @picture.zoom_y / 100.0
    self.opacity = @picture.opacity
    self.blend_type = @picture.blend_type
    self.angle = @picture.angle
    self.tone = @picture.tone
    self.color = @picture.flash_color
  end
end

class Scene_Map
  attr_reader :spriteset
end

class Spriteset_Map
  attr_accessor :picture_sprites
end

Llamadas de script:
$game_screen.pictures[ID].name = "Nombre Picture" - Cambia el gráfico de la picture
$game_screen.pictures[ID].sprite - Obtiene el sprite de la picture
$game_screen.pictures[ID].flash(Color.new(R, G, B), DURACIÓN) - Cambiando R, G, B por valores 0-255, aplica un flash de ese color al sprite
avatar
Wecoc
Administrador
Administrador



Créditos 12310

Gracias : 654

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Recopilación de scripts 'no publicados' de Wecoc

Mensaje por Wecoc el 2018-11-14, 02:09

Hay menos de los que creía porque muchos son demasiado específicos para el sistema, pero bueno, creo que sigue siendo una buena recopilación contando los links.

6. Water Panoramas
Usado en: Sistema de Buceo de Wecoc, compatible con todo

Este script es como un "parallax fragmentado". Lo que hace es definir panoramas que scrollean con el mapa, pero ocupan solo una parte y además es fácil obtener su sprite para aplicarles cierto efecto. Aunque el nombre confunda un poco en verdad no son Panoramas sino más bien Pictures que han estado alteradas para funcionar tal como lo haría un parallax.

En el engine se usan para definir el fondo de cada lago, y además se les aplica un efecto ondeante para dar el efecto de agua, de ahí el nombre del script. Todo eso puede configurarse dentro del propio script.

Código:
#==============================================================================
# ** [XP] Water Panoramas
#------------------------------------------------------------------------------
# Este script forma parte del Sistema de Buceo de Wecoc
# Permite definir sprites que representan el fondo del agua, es decir son como
# Panoramas pero delimitados solo a una parte del mapa. Eso permite aplicarles
# efectos como el Wave Effect sin que esto afecte al lag.
# Se definen en el método set_default_water_sprites del script o bien vía
# llamada de evento usando el método set_water_sprite(x, y, name)
#==============================================================================

class Spriteset_Map
  #----------------------------------------------------------------------------
  unless $@
    alias water_spr_ini initialize
    alias water_spr_dis dispose
    alias water_spr_upd update
  end
  #----------------------------------------------------------------------------
  # * Initialize
  #----------------------------------------------------------------------------
  def initialize
    @water_sprites = []
    set_default_water_sprites
    water_spr_ini
  end
  #----------------------------------------------------------------------------
  # * Definir los Water Panoramas en cada mapa
  #----------------------------------------------------------------------------
  def set_default_water_sprites
    #------------ Configuration ---------------
    case $game_map.map_id
    when 2, 3
      set_water_sprite(-1, 3, "water001")
      set_water_sprite( 4, 1, "water002")
    end
    #------------ Configuration ---------------
  end
  #----------------------------------------------------------------------------
  # * Dispose
  #----------------------------------------------------------------------------
  def dispose
    water_spr_dis
    clear_water_sprites
  end
  #----------------------------------------------------------------------------
  # * Update
  #----------------------------------------------------------------------------
  def update
    water_spr_upd
    @water_sprites.each do |sprite|
      sprite.update
      sprite.ox = $game_map.display_x / 4
      sprite.oy = $game_map.display_y / 4
    end
  end
  #----------------------------------------------------------------------------
  # * Crear nuevo sprite de agua
  #----------------------------------------------------------------------------
  def set_water_sprite(x, y, name)
    picture = RPG::Cache.picture(name) rescue nil
    return if picture.nil?
    sprite = RPG::Sprite.new(@viewport1)
    sprite.bitmap = picture
    sprite.x = x * 32
    sprite.y = y * 32
    sprite.ox = $game_map.display_x / 4
    sprite.oy = $game_map.display_y / 4
    sprite.z = -1000
    #sprite.wave_amp = 1
    #sprite.wave_speed = 1000
    #sprite.wave_phase = 1.25
    @water_sprites.push(sprite)
  end
  #----------------------------------------------------------------------------
  # * Borrar los sprites de agua actuales
  #----------------------------------------------------------------------------
  def clear_water_sprites
    @water_sprites.each{|sprite| sprite.dispose}
    @water_sprites.clear
  end
end

class Interpreter
  #----------------------------------------------------------------------------
  # * Crear nuevo sprite de agua (atajo para eventos)
  #----------------------------------------------------------------------------
  def set_water_sprite(x, y, name)
    spriteset = $scene.instance_eval("@spriteset")
    return if spriteset.nil?
    spriteset.set_water_sprite(x, y, name)
  end
  #----------------------------------------------------------------------------
  # * Borrar los sprites de agua actuales (atajo para eventos)
  #----------------------------------------------------------------------------
  def clear_water_sprites
    spriteset = $scene.instance_eval("@spriteset")
    return if spriteset.nil?
    spriteset.clear_water_sprites
  end
end

Normalmente no necesitarás ninguna llamada de script porque es todo configurable en el mismo, pero puse un par por si acaso quieren hacerse cambios desde evento.

Llamadas de script:
set_water_sprite(X, Y, NOMBRE) - Carga un nuevo panorama al mapa como fondo de lago
clear_water_sprites - Borra todos los panoramas de fondo de lago

7. Water Depth
Usado en: Sistema de Buceo de Wecoc, solo reescribe Game_Event:through

Este script puede parecer muy concreto del sistema en sí pero en verdad creo que algunas de sus propiedades se pueden generalizar. Lo que hace es definir una nueva variable de evento llamada "profundidad" (entiéndase como profundidad dentro del agua). Lo que es interesante es que tanto la pasabilidad como la interacción con eventos depende de esta, pudiendo asignar zonas con profundidad mínima y profundidad máxima para poder pasar, eventos flotantes/en el fondo, etc. El script también modifica el gráfico del evento según su profundidad pero eso puede quitarse fácilmente eliminando su apartado Sprite_Character.

Código:
#==============================================================================
# ** [XP] Water Depth
#------------------------------------------------------------------------------
# Este script forma parte del Sistema de Buceo de Wecoc
# Este script contiene todo lo necesario para la mecánica de buceo:
# Altura, pasabilidad, cambio en el Sprite, etc.
# No requiere configuración
#==============================================================================

#==============================================================================
# ** Game_Character
#==============================================================================

class Game_Character
  #----------------------------------------------------------------------------
  attr_accessor :depth
  #----------------------------------------------------------------------------
  # * Initialize
  #----------------------------------------------------------------------------
  alias set_depth_ini initialize unless $@
  def initialize
    set_depth_ini
    @depth = 0.0
    @depth_target = 0.0
    @depth_duration = 0
  end
  #----------------------------------------------------------------------------
  # * Definir nuevo depth (subir/bajar)
  #----------------------------------------------------------------------------
  def start_depth_change(depth, duration)
    @depth_target = depth.to_f
    @depth_duration = duration * 2
    if @depth_duration == 0
      @depth = depth.clone
    end
  end
  #----------------------------------------------------------------------------
  # * Comprobar si está subiendo o bajando
  #----------------------------------------------------------------------------
  def moving_depth?
    return @depth != @depth_target
  end
  #----------------------------------------------------------------------------
  # * Update
  #----------------------------------------------------------------------------
  alias set_depth_upd update unless $@
  def update
    if @depth_duration >= 1
      d = @depth_duration
      @depth = (@depth * (d - 1) + @depth_target) / d
      @depth_duration -= 1
    end
    set_depth_upd
  end
  #----------------------------------------------------------------------------
  # * Pasabilidad
  #----------------------------------------------------------------------------
  alias water_depth_passable? passable? unless $@
  def passable?(x, y, d)
    if @depth > 0
      new_x = x + (d == 6 ? 1 : d == 4 ? -1 : 0)
      new_y = y + (d == 2 ? 1 : d == 8 ? -1 : 0)
      new_d = $game_map.water_depth[$game_map.coords_to_index(new_x, new_y)]
      return false if new_d.nil?
      # No es pasable si el depth del personaje no entra dentro del
      # rango de profundidades mínimo/máximo del tile
      return false if @depth > new_d.max or @depth < new_d.min
    end
    return water_depth_passable?(x, y, d)
  end
end

#==============================================================================
# ** Game_Event
#==============================================================================

class Game_Event < Game_Character
  #----------------------------------------------------------------------------
  # * Bugfix Through: Aunque no sea pasable, si está hundido sí lo es
  #----------------------------------------------------------------------------
  def through
    return true if @depth > $game_player.depth
    return @through
  end
end

#==============================================================================
# ** Sprite_Character
#==============================================================================

class Sprite_Character < RPG::Sprite
  #----------------------------------------------------------------------------
  # * Update
  #----------------------------------------------------------------------------
  alias get_depth_upd update unless $@
  def update
    get_depth_upd
    if @character.depth > 0
      # Aquí se cambia la posición & opacidad del personaje según depth
      self.y = @character.screen_y + (@character.depth * 8).to_i
      self.z = @character.screen_z(@ch) - (@character.depth * 8).to_i
      self.opacity = @character.opacity - (@character.depth * 64).to_i
    end
  end
end

#==============================================================================
# ** Game_Map
#==============================================================================

class Game_Map
  #----------------------------------------------------------------------------
  attr_accessor :water_depth
  #----------------------------------------------------------------------------
  # * Setup
  #----------------------------------------------------------------------------
  alias water_depth_setup setup unless $@
  def setup(*args)
    water_depth_setup(*args)
    @water_depth = {}
    @water_sprites = []
  end
  #----------------------------------------------------------------------------
  # * Cargar pasabilidad de otro ID de tileset (Tierra/Agua)
  #----------------------------------------------------------------------------
  def load_passability(tileset_id)
    tileset = $data_tilesets[tileset_id]
    @passages = tileset.passages
    @priorities = tileset.priorities
    @terrain_tags = tileset.terrain_tags
  end
  #----------------------------------------------------------------------------
  # * Pasar coordenadas a un único índice
  #----------------------------------------------------------------------------
  def coords_to_index(x, y)
    return x + y * self.width
  end
  #----------------------------------------------------------------------------
  # * Pasar índice a coordenadas
  #----------------------------------------------------------------------------
  def index_to_coords(id)
    x = id % self.width
    y = (id - x) / self.width
    return x, y
  end
  #----------------------------------------------------------------------------
  # * Update
  #----------------------------------------------------------------------------
  alias water_depth_upd update unless $@
  def update
    water_depth_upd
    # Si estás en modo Debug al pulsar CTRL aparecen sprites que indican
    # la profundidad máxima (verde) y mínima (rojo) en cada tile
    @water_sprites.each do |sprite|
      sprite.update
      sprite.ox = @display_x / 4
      sprite.oy = @display_y / 4
    end
    if $DEBUG == true
      if Input.trigger?(Input::CTRL)
        for i in @water_depth.keys
          x, y = index_to_coords(i)
          max_depth = @water_depth[i].max - @water_depth[i].min
          if max_depth > 0
            sprite = Sprite.new()
            sprite.bitmap = Bitmap.new(32, 32)
            color = Color.new(128, 255, 64, 32 * max_depth)
            sprite.bitmap.fill_rect(sprite.bitmap.rect, color)
            sprite.x = x * 32
            sprite.y = y * 32
            sprite.ox = @display_x / 4
            sprite.oy = @display_y / 4
            @water_sprites.push(sprite)
          end
          min_depth = @water_depth[i].min
          if min_depth > 0
            sprite = Sprite.new()
            sprite.bitmap = Bitmap.new(32, 32)
            color = Color.new(255, 64, 0, 32 * min_depth)
            sprite.bitmap.fill_rect(sprite.bitmap.rect, color)
            sprite.x = x * 32
            sprite.y = y * 32
            sprite.ox = @display_x / 4
            sprite.oy = @display_y / 4
            @water_sprites.push(sprite)
          end
        end
      end
      if !Input.press?(Input::CTRL) && @water_sprites.size > 0
        @water_sprites.each {|sprite| sprite.dispose}
        @water_sprites.clear
      end
    end
  end
end

#==============================================================================
# ** Interpreter
#==============================================================================

class Interpreter
  #----------------------------------------------------------------------------
  # Obtener la profundidad máxima en una determinada coordenada
  #----------------------------------------------------------------------------
  def get_water_depth_max(x, y)
    index = $game_map.coords_to_index(x, y)
    return 0 if $game_map.water_depth[index].nil?
    return $game_map.water_depth[index].max
  end
  #----------------------------------------------------------------------------
  # Obtener la profundidad mínima en una determinada coordenada
  #----------------------------------------------------------------------------
  def get_water_depth_min(x, y)
    index = $game_map.coords_to_index(x, y)
    return 0 if $game_map.water_depth[index].nil?
    return $game_map.water_depth[index].min
  end
  #----------------------------------------------------------------------------
  # Asignar las profundidades máxima e mínima en una coordenada
  #----------------------------------------------------------------------------
  def set_water_depth(x, y, max, min=0)
    index = $game_map.coords_to_index(x, y)
    $game_map.water_depth[index] = [max, min]
  end
  #----------------------------------------------------------------------------
  # Atajo matricial para asignar profundidad máxima a muchos tiles a la vez
  #----------------------------------------------------------------------------
  def max_depth_matrix(x, y, array)
    for iy in 0...array.size
      for ix in 0...array[iy].size
        next if array[iy][ix] <= 0
        set_water_depth(x + ix, y + iy, array[iy][ix])
      end
    end
  end
  #----------------------------------------------------------------------------
  # Atajo matricial para asignar profundidad mínima a muchos tiles a la vez
  #----------------------------------------------------------------------------
  def min_depth_matrix(x, y, array)
    for iy in 0...array.size
      for ix in 0...array[iy].size
        next if array[iy][ix] <= 0
        old = $game_map.water_depth[$game_map.coords_to_index(x + ix, y + iy)]
        old = [array[iy][ix]] if old.nil?
        set_water_depth(x + ix, y + iy, old.max, array[iy][ix])
      end
    end
  end
end

Llamadas de script:
Nota: Todos los métodos aplicados a $game_player (personaje) también son aplicables a $game_map.events[ID] (evento)

$game_player.depth = VALOR - Asignar profundidad del personaje, por defecto 0
$game_player.start_depth_change(VALOR, DURACIÓN) - Similar al anterior pero de modo suave
$game_player.moving_depth? - Comprueba si está subiendo/bajado de modo suave
$game_map.load_passability(TILESET ID) - Cargar pasabilidades de otra ranura de tileset (Base de Datos)
get_water_depth_max(X, Y) - Obtener la profundidad máxima en una determinada coordenada
get_water_depth_min(X, Y) - Obtener la profundidad mínima en una determinada coordenada
set_water_depth_min(X, Y, MAX, MIN) - Asignar las profundidades máxima e mínima en una coordenada

También hay dos atajos para asignar múltiples profundidades a la vez pero son algo complejas, mirad el engine para ver ejemplos de eso.

8. Event Preserve Add-on
Usado en: Sistema de Buceo de Wecoc, compatible con todo

Este script hace que al transportarte al mapa siguiente determinados eventos del mapa anterior se mantengan justo donde estaban, pero en el nuevo mapa. Eso sí, el nuevo evento mantiene el ID así que si el nuevo mapa tiene un evento con esa ID asignada, el preservado reescribirá el propio del mapa. Al cambiar de mapa la lista de preservados se vacía automáticamente. Lo típico será en el nuevo mapa volver a definir el mismo evento como preservado, de modo que al volver atrás siga siendo el mismo. Si no lo entendéis mirad Rick & Morty.

Código:
#==============================================================================
# ** [XP] Event Preserve Add-on
#------------------------------------------------------------------------------
# Este add-on permite conservar eventos de un mapa a otro al teletransportar
# Solo hay que usar preserve_event(ID) en una llamada de script antes de
# transportarse
#==============================================================================

class Game_Temp
  attr_accessor :preserve_events
  alias pre_ev_ini initialize unless $@
  def initialize
    pre_ev_ini
    @preserve_events = []
  end
end
class Game_Map
  alias pre_ev_setup setup unless $@
  def setup(*args)
    preserve_events = {}
    for i in $game_temp.preserve_events
      preserve_events[i] = @events[i]
    end
    $game_temp.preserve_events.clear
    pre_ev_setup(*args)
    for i in preserve_events.keys
      @events[i] = preserve_events[i]
    end
  end
end
class Interpreter
  def preserve_event(event_id)
    $game_temp.preserve_events.push(event_id)
  end
end

Llamadas de script:
preserve_event(ID de Evento) - Añadir a la lista de preservados para que al teletransportarte ese evento se mantenga
$game_temp.preserve_events - Obtener las ID de los eventos que serán preservados
$game_temp.preserve_events.clear - Quitar de la lista de preservados todos los eventos

9. Audio Fade
Lo hice hace tiempo y no llegué a subirlo, es compatible con casi todo.

Este script permite cambiar el volumen de BGM y BGS de modo suave.

Código:
#==============================================================================
# ** [XP] Audio Fade
#------------------------------------------------------------------------------
# Este script permite cambiar el volumen de BGM y BGS de modo suave.
# Para usarlo:
#   AudioFade.fade_bgm(VOLUMEN, FRAMES)
#   AudioFade.fade_bgs(VOLUMEN, FRAMES)
# Ejemplo: AudioFade.fade_bgm(20, 60) # Bajar el volumen a 20, 3 segundos
# Esas llamadas de script se pueden hacer desde evento o en cualquier parte
#==============================================================================

module AudioFade
  #--------------------------------------------------------------------------
  module_function
  #--------------------------------------------------------------------------
  def initialize
    @fade_bgm = false
    @fade_bgm_start = 100
    @fade_bgm_end = 100
    @fade_bgm_frames = 0
    @fade_bgm_duration = 0
    @fade_bgs = false
    @fade_bgs_start = 100
    @fade_bgs_end = 100
    @fade_bgs_frames = 0
    @fade_bgs_duration = 0
  end
  #--------------------------------------------------------------------------
  def fade_bgm(volume, duration=0)
    return if $game_system.nil? or $game_system.playing_bgm.nil?
    playing = $game_system.playing_bgm
    return if playing.name == ""
    if duration == 0
      bgm = RPG::AudioFile.new(playing.name, volume, playing.pitch)
      $game_system.bgm_play(bgm)
      return
    end
    @fade_bgm = true
    @fade_bgm_start = playing.volume
    @fade_bgm_end = volume
    @fade_bgm_frames = duration * 2
    @fade_bgm_duration = duration * 2
  end
  #--------------------------------------------------------------------------
  def fade_bgs(volume, duration=0)
    return if $game_system.nil? or $game_system.playing_bgs.nil?
    playing = $game_system.playing_bgs
    return if playing.name == ""
    if duration == 0
      bgs = RPG::AudioFile.new(playing.name, volume, playing.pitch)
      $game_system.bgs_play(bgs)
      return
    end
    @fade_bgs = true
    @fade_bgs_start = playing.volume
    @fade_bgs_end = volume
    @fade_bgs_frames = duration * 2
    @fade_bgs_duration = duration * 2
  end
  #--------------------------------------------------------------------------
  def update
    if @fade_bgm == true
      d = @fade_bgm_duration
      diff = (@fade_bgm_end - @fade_bgm_start) * d
      volume = @fade_bgm_end - (diff / @fade_bgm_frames)
      playing = $game_system.playing_bgm
      bgm = RPG::AudioFile.new(playing.name, volume, playing.pitch)
      $game_system.bgm_play(bgm)
      @fade_bgm_duration -= 1
      @fade_bgm = false if @fade_bgm_duration == 0
    end
    if @fade_bgs == true
      d = @fade_bgs_duration
      diff = (@fade_bgs_end - @fade_bgs_start) * d
      volume = @fade_bgs_end - (diff / @fade_bgs_frames)
      playing = $game_system.playing_bgs
      bgs = RPG::AudioFile.new(playing.name, volume, playing.pitch)
      $game_system.bgs_play(bgs)
      @fade_bgs_duration -= 1
      @fade_bgs = false if @fade_bgs_duration == 0
    end
  end
end

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

AudioFade.initialize
module Graphics
  class << self
    alias audiofade_addon_upd update unless $@
    def update
      audiofade_addon_upd
      AudioFade.update
    end
  end
end

Llamadas de script:
AudioFade.fade_bgm(VOLUMEN, FRAMES) - Pasar el BGM a un determinado volumen
AudioFade.fade_bgs(VOLUMEN, FRAMES) - Pasar el BGS a un determinado volumen

Add-on para habilidades:
Si queréis que al aplicar una habilidad concreta se baje el BGM momentáneamente, es fácil añadir ese add-on al script anterior.
Lo he hecho aquí como ejemplo, solo hay que configurar las ID de las habiliaddes.

Código:
module AudioFade
  # ID de las Skills que bajan el BGM a la mitad cuando son aplicadas
  FADE_SKILLS = [1, 2, 3, 4, 5, 6, 7, 8, 9]
end

class Scene_Battle
  alias fade_skills_action_result make_skill_action_result unless $@
  def make_skill_action_result
    if AudioFade::FADE_SKILLS.include?(@active_battler.current_action.skill_id)
      @skill_fade_out = true
      @skill_bgm_volume = $game_system.playing_bgm.volume
      AudioFade.fade_bgm(50, 10)
    end
    fade_skills_action_result
  end
  alias fade_skills_restore update_phase4_step5 unless $@
  def update_phase4_step5
    if @skill_fade_out
      @skill_fade_out = false
      AudioFade.fade_bgm(@skill_bgm_volume, 10)
    end
    fade_skills_restore
  end
end
avatar
Wecoc
Administrador
Administrador



Créditos 12310

Gracias : 654

Volver arriba Ir abajo

RPG Maker XP Re: [XP] Recopilación de scripts 'no publicados' de Wecoc

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.