|
|||||||
 |
|
|
Herramientas | Desplegado |
|
#21
03-dic-2008, 18:11
|
||||
|
||||
Re: ~Base De Datos de Script de EMD~
-Nombre Del Script:Phone System -Version Del Script:0.1B -Rpg Maker:VX -Introducion: Es un sistema de telefonía móvil, que esta en su primera beta, por lo tanto tiene mucho que mejorar y se pueden encontrar bugs. Con él tienes un telefono movil, con el cual puedes recibir sms de los NPC. -Demo: http://www.mediafire.com/download.php?zwzkuetixvv -ScreenShot:
Spoiler
    -Script: no disponible -Creditos: Necrozard 
|
|
|
|||
|
|||
|
~Base De Datos de Script de EMD~
|
|
#23
12-dic-2008, 03:50
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
Última edición por Alkimista_Zieg fecha: 12-dic-2008 a las 04:48.
|
|
#24
15-dic-2008, 21:11
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
-Nombre Del Script:Tetris
-Version Del Script:no hay informacion -Rpg Maker:XP -Introducion: Este script no necesita de ningun grafico adicional solamente lo pegan arriba del main y listo.. Esta en frances la explicacion pero lo q se ve en el juego en español (traducido by Yo: Dubriel) como bien dice la explicacion para empezar el juego usar el comando(en llamar script): Tetris.start Con la barra espaciadora se rotan las figuras -ScreenShot:  -Script:
Spoiler
Código:
#-------------------------------------------------------------------------------------------------------------------------------
#Dans un evenement, faire "inserer un script" et taper :
#Pour lancer le jeu
#Tetris.start(niveau)
#remplacer niveau par le niveau auquel le jeu commence (1 par défaut)
#-------------------------------------------------------------------------------------------------------------------------------
#Pour recuperer le score dans une variable :
#Tetris.score_to_var(num)
#En replaçant num par le numéro de la variable
#De même pour récuperer le nombre de ligne détruite ou le niveau atteint :
#Tetris.ligne_to_var(num)
#ou
#Tetris.niveau_to_var(num)
#=======================================================================
module Tetris
#Le fond d'écran : remplacer nil par le nom du fichier sans l'extension ( doit se trouver dans le dossier Pictures).
FOND_ECRAN = nil
#Changer les deux premieres coordonnés pour déplacer les différents éléments du jeu
ECRAN_JEU = Viewport.new(52, 0, 210, 462)
ECRAN_PIECE = Rect.new(400, 80, 116, 116)
ECRAN_SCORE = Rect.new(360, 220, 200, 122)
#======================================================================
#Définitions des différentes pieces avec leurs couleurs
#======================================================================
PIECES = [[[[false, false, false, false],
[false, true, true, false],
[false, true, true, false],
[false, false, false, false]],
Color.new(0, 0, 255)],
[[[false, true, false, false],
[false, true,false, false],
[false, true, false, false],
[false, true, false, false]],
Color.new(255, 0, 0)],
[[[false, false, false, false],
[false, true, false, false],
[true, true, true, false],
[false, false, false, false]],
Color.new(255, 85, 0)],
[[[false, false, false, false],
[false, true,true, false],
[true, true, false, false],
[false, false, false, false]],
Color.new(0, 255, 0)],
[[[false, false, false, false],
[false, true,true, false],
[false, false, true, true],
[false, false, false, false]],
Color.new(255, 0, 255)],
[[[false, false, false, false],
[false, false,true, false],
[true, true, true, false],
[false, false, false, false]],
Color.new(255, 255, 0)],
[[[false, false, false, false],
[true, false,false, false],
[true, true, true, false],
[false, false, false, false]],
Color.new(119, 85, 136)]]
#=======================================================================
#Demarre le jeu
#=======================================================================
def Tetris.start(n = 1)
@score = 0
@ligne = 0
@niveau = 0
$scene = Scene_Jeu.new(n)
end
#=======================================================================
#Score, nombre de lignes détruites et niveau
#=======================================================================
def Tetris.score(s = 0)
@score += s
return @score
end
def Tetris.score_to_var(n)
$game_variables[n] = @score
end
def Tetris.ligne(l = 0)
@ligne += l
return @ligne
end
def Tetris.ligne_to_var(n)
$game_variables[n] = @ligne
end
def Tetris.niveau(n = 0)
@niveau += n
return @niveau
def Tetris.niveau_to_var(n)
$game_variables[n] = @niveau
end
end
#=======================================================================
#PIECE
#=======================================================================
class Piece < Sprite
attr_reader :matrice
def initialize
super(ECRAN_JEU)
@piece = PIECES[rand(7)]
@matrice = @piece[0]
self.bitmap = Bitmap.new(84, 84)
@couleur = @piece[1]
self.y = 0
self.x = 42
@undo = proc {self.visible = false}
refresh
end
def refresh
self.bitmap.clear
4.times do |i|
4.times do |j|
if @matrice[j][i]
rect1 = Rect.new(21 * i, 21 * j, 21, 21)
rect2 = Rect.new(21 * i + 1, 21 * j + 1, 19, 19)
self.bitmap.fill_rect(rect1, Color.new(0, 255, 255))
self.bitmap.fill_rect(rect2, @couleur)
end
end
end
end
def move_left
@undo = proc {move_right}
self.x -= 21
end
def move_right
@undo = proc {move_left}
self.x += 21
end
def rotate_right
@undo = proc {rotate_left}
piece = [[],[],[],[]]
4.times do |i|
4.times do |j|
piece[i][j] = @matrice[3 - j][i]
end
end
@matrice = piece
refresh
end
def rotate_left
@undo = proc {rotate_right}
piece = [[],[],[],[]]
4.times do |i|
4.times do |j|
piece[i][j] = @matrice[j][3 - i]
end
end
@matrice = piece
refresh
end
def move
@undo = proc {self.y -= 21}
self.y += 21
end
def undo
@undo.call
end
end
#=======================================================================
#Affichage du score
#=======================================================================
class Score < Window_Base
def initialize
super(ECRAN_SCORE.x, ECRAN_SCORE.y, ECRAN_SCORE.width, ECRAN_SCORE.height)
self.contents = Bitmap.new(self.width - 32, self.height - 32)
self.contents.font = Font.new($fontface , 24)
self.contents.font.color = Color.new(255, 255, 0)
self.opacity = 180
self.z = 2
refresh
end
def refresh
self.contents.clear
self.contents.draw_text(0, 0, 200, 30, "Nivel : #{Tetris.niveau}")
self.contents.draw_text(0, 30, 200, 30, "Lineas : #{Tetris.ligne}")
self.contents.draw_text(0, 60, 200, 30, "Puntaje : #{Tetris.score}")
end
def niveau(l)
Tetris.niveau(1) if Tetris.ligne / 10 != Tetris.ligne(l) / 10
Tetris.score(10 * l * (l + 1) / 2)
refresh
end
end
#======================================================================
#fenetre pour afficher la piece suivante
#======================================================================
class Window_Piece < Window_Base
def initialize
super(ECRAN_PIECE.x, ECRAN_PIECE.y, ECRAN_PIECE.width, ECRAN_PIECE.height)
self.opacity = 180
self.z = 2
end
end
#=======================================================================
#Fenetre de fin du jeu
#=======================================================================
class Window_Fin < Window_Base
def initialize
super(150, 100, 300, 100)
self.contents = Bitmap.new(self.width - 32, self.height - 32)
self.contents.font = Font.new($fontface, 40)
self.contents.font.color = Color.new(255, 255, 0)
self.z = 10
refresh
end
def refresh
self.contents.clear
self.contents.draw_text(0, 14, self.width - 32, 40, "Puntaje : #{Tetris.score}", 1)
end
end
#=======================================================================
#Scene du jeu
#=======================================================================
class Scene_Jeu
def initialize(niveau = 1)
@ecran_jeu = Sprite.new(ECRAN_JEU)
@ecran_jeu.bitmap = Bitmap.new(210, 462)
@window_piece = Window_Piece.new
bgm_play = "mario"
unless FOND_ECRAN == nil
@fond = Plane.new
@fond.bitmap = Bitmap.new("Graphics/Pictures/amigo")
@fond.z = -1
end
@piece = Piece.new
@suivante = Piece.new
@suivante.visible = false
@window_piece.contents = @suivante.bitmap
@puit = Array.new(24)
24.times do |y|
@puit[y] = Array.new(12, false)
@puit[y][0] = @puit [y][11] = true
end
12.times do |x|
@puit[22][x] = @puit[23][x] = true
end
afficher_puit
@vitesse = 0.75**niveau
@temps = Time.new
Tetris.niveau(niveau)
@ligne = 0
@score = Score.new
end
def main
Graphics.transition
loop do
Graphics.update
Input.update
update
break if $scene != self
end
@piece.dispose
@score.dispose
@fond.dispose unless FOND_ECRAN == nil
@suivante.dispose
@ecran_jeu.dispose
@murs.dispose
@window_piece.dispose
end
def update
@piece.move_left if Input.repeat?(Input::LEFT)
@piece.move_right if Input.repeat?(Input::RIGHT)
@piece.rotate_left if Input.trigger?(Input::C)
@piece.undo if test_piece
game_over if Input.trigger?(Input::B)
if Input.press?(Input::DOWN)
Graphics.update
Graphics.update
@temps = Time.new
@piece.move
pose_piece if test_piece
elsif (Time.new - @temps) > @vitesse
@temps = Time.new
@piece.move
pose_piece if test_piece
end
end
#=======================================================================
#Affiche le puit
#=======================================================================
def afficher_puit
@murs = Sprite.new
@murs.bitmap = Bitmap.new(252,483)
@murs.x = ECRAN_JEU.rect.x - 21
@murs.y = ECRAN_JEU.rect.y
@murs.z = 1
23.times do |y|
@murs.bitmap.fill_rect(0, 21 * y, 21, 21, Color.new(136, 92, 189))
@murs.bitmap.fill_rect(1, 21 * y + 1, 19, 19, Color.new(67, 210, 154))
@murs.bitmap.fill_rect(231, 21 * y, 21, 21, Color.new(136, 92, 189))
@murs.bitmap.fill_rect(232, 21 * y + 1, 19, 19, Color.new(67, 210, 154))
end
for x in 1..10
@murs.bitmap.fill_rect(21 * x, 462, 21, 21, Color.new(136, 92, 189))
@murs.bitmap.fill_rect(21 * x + 1, 463, 19, 19, Color.new(67, 210, 154))
end
end
#=======================================================================
#Teste si la piece est bien placé
#=======================================================================
def test_piece
x = @piece. x / 21 + 1
y = @piece.y / 21
4.times do |j|
4.times do |i|
return true if @piece.matrice[ j][i] and @puit[y + j][x + i]
end
end
return false
end
#=======================================================================
#Pose la piece
#=======================================================================
def pose_piece
@piece.undo
@ecran_jeu.bitmap.blt(@piece.x, @piece.y, @piece.bitmap, Rect.new(0, 0, 84, 84))
x = @piece. x / 21 + 1
y = @piece.y / 21
4.times do |j|
4.times do |i|
@puit[y + j][x + i] = true if @piece.matrice[j][i]
end
end
count = 0
for i in y..[y + 4, 21].min do
if test_ligne(i)
supprime_ligne(i)
count += 1
end
end
@score.niveau(count)
@vitesse = 0.75**Tetris.niveau
@piece.dispose
@piece = @suivante
@piece.visible = true
if test_piece
@piece.undo
game_over
end
@suivante = Piece.new
@suivante.visible = false
@window_piece.contents = @suivante.bitmap
end
#=======================================================================
#teste si une ligne est complété
#=======================================================================
def test_ligne(y)
r = true
for x in 1..10 do
unless @puit[y][x]
r = false
break
end
end
return r
end
#=======================================================================
#Supprime une ligne
#========================================================================
def supprime_ligne(ligne)
y = ligne * 21
image = Bitmap.new(210, 462)
image.blt(0, 21, @ecran_jeu.bitmap, Rect.new(0, 0, 210, y))
image.blt(0, y + 21, @ecran_jeu.bitmap, Rect.new(0, y + 21, 210, 451 - y))
@ecran_jeu.bitmap.clear
@ecran_jeu.bitmap.blt(0, 0, image, Rect.new(0, 0, 210, 462))
tableau = Array.new(24)
24.times {|l| tableau[l] = Array.new(12, false)}
24.times do |j|
12.times do |i|
if j < ligne
tableau[j + 1][i] = @puit[j][i]
elsif j > ligne
tableau[j][i] = @puit[j][i]
end
end
end
tableau[0][0] = tableau [0][11] = true
@puit = tableau
end
def game_over
@window = Window_Fin.new
loop do
Graphics.update
Input.update
break if Input.trigger?(Input::C)
end
$scene = Scene_Map.new
@window.dispose
end
end
end
-Creditos: Dubriel
|
|
#25
15-dic-2008, 21:45
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
-Nombre Del Script:SCRIPT DE ALQUIMIA
-Version Del Script:1.0 -Rpg Maker:XP -Introducion: Su función es devolver una serie de objetos al combinar otra serie de objeto. Por ejemplo: mezclamos dos "Poción" con una "Super Poción" y obtenemos dos "Super Poción". Esto es solo un ejemplo, pero se pueden crear infinidad de fórmulas y combinaciones. Además, se puede restringir el tipo de objetos a mezclar, de forma que solo se pueda utilizar en la mezcla los objetos que lleven el atributo X. -Caracteristicas Capacidad de utilizar infinidad de fórmulas. Puedes añadir tantos ingredientes o resultados a una fórmula como te apetezca. Puedes hacer que sólo ciertos objetos puedan utilizarse en la mezc -Demo: http://files.filefront.com/Alquimiae.../fileinfo.html -ScreenShot:
Spoiler
-Script
Spoiler
Código:
#-------------------------------------------------------------------------
# Script de alquimia
#-------------------------------------------------------------------------
# - Versión: 1.1
# - Autor: Alnain (no son necesarios créditos)
# - Creado: 11 - 9 - 08 (dd - mm - aa)
# - Instrucciones:
# · Pegar encima de main.
# · Para ir a la pantalla de alquimia usa lo siguiente en un llamar
# script: $scene = Scene_Alquimia.new.
# · Selecciona el atributo ingrediente para los objetos que quieras que
# combinables
# · Edita la parte editabe a tu gusto.
class Scene_Alquimia # no editar esta línea
#-------------------------------------------------------------------------
#----EDITABLE DESDE AQUI -------------------------------------------------
#-------------------------------------------------------------------------
def initialize
# Id del atributo "Ingrediente" (editable)
$atr_ingrediente = 17
#---Combinaciones-----
@combinaciones = { # no editar esta línea
# Las comabinaciones se definen así:
#
# [ingrediente, ingrediente, ingrediente] => [resultado, resultado],
#
# La última combinación no debe llevar la coma al final.
# Ingrediente y resultado son IDs de objetos en la base de datos.
# Puedes crear tantas combinaciones como quieras.
# Puedes añadir tantos ingredientes como quieras a cada combinación.
# Puedes añadir tantos resultados como quieras a cada combinación.
[33, 34] => [11, 11],
[35, 37] => [15, 22],
[34, 38, 39] => [12],
[35, 37, 40] => [13]
} # no editar esta línea
#-------------------------------------------------------------------------
#----EDITABLE HASTA AQUI -------------------------------------------------
#-------------------------------------------------------------------------
end
def main
@items_window = Window_Items.new
@items_window.y = 64
@mezcla_window = Window_Mezcla.new
@mezcla_window.x = 320
@mezcla_window.y = 64
@mezcla_window.active = false
@command_window = Window_Inst.new
@command_window.x = 320
@command_window.y = 384
@info_window = Window_Info.new
@info_window.x = 320 - @info_window.width / 2
@info_window.y = 240 - @info_window.height / 2
@info_window.z = 9999
@info_window.visible = false
@info_window.set_info
@description_window = Window_Help.new
if not @items_window.item.nil?
@description_window.set_text (@items_window.item.description)
end
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
#disposes
@items_window.dispose
@mezcla_window.dispose
@command_window.dispose
@description_window.dispose
end
def update
@items_window.update
@mezcla_window.update
if @items_window.active
if not @items_window.item.nil?
@description_window.set_text (@items_window.item.description)
else
@description_window.set_text ("")
end
else
if not @mezcla_window.item.nil?
item = $data_items[@mezcla_window.item]
@description_window.set_text (item.description)
else
@description_window.set_text ("")
end
end
if Input.trigger? (Input::LEFT)
if @mezcla_window.active
@mezcla_window.active = false
@items_window.active = true
end
elsif Input.trigger? (Input::RIGHT)
if @items_window.active
@mezcla_window.active = true
@items_window.active = false
end
end
if Input.trigger? (Input::C)
if @items_window.active and not @items_window.item.nil?
@mezcla_window.añadir_ingrediente (@items_window.item.id)
@mezcla_window.refresh
$game_party.lose_item (@items_window.item.id, 1)
@items_window.index = [0, @items_window.index - 1].max
@items_window.refresh
elsif @mezcla_window.active and not @mezcla_window.item.nil?
$game_party.gain_item (@mezcla_window.item, 1)
@items_window.refresh
@mezcla_window.quitar_ingrediente
@mezcla_window.index = [0, @mezcla_window.index - 1].max
@mezcla_window.refresh
else
@items_window.active = true
@info_window.visible = false
end
end
if Input.trigger? (Input::X)
vaciar (true)
elsif Input.trigger? (Input::A)
mezclar
end
if Input.trigger? (Input::B)
vaciar (true)
$scene = Scene_Map.new
end
end
def vaciar (devolver)
items = @mezcla_window.items
for item in items
$game_party.gain_item (item, 1) if devolver
@mezcla_window.quitar_ingrediente
end
@mezcla_window.refresh
@items_window.refresh
end
def mezclar
existe = false
for combinacion in @combinaciones.keys
if @mezcla_window.items == combinacion.sort
existe = true
end
end
if existe
resultado = @combinaciones[@mezcla_window.items]
for item in resultado
$game_party.gain_item (item, 1)
end
else
resultado = []
end
vaciar (false)
@items_window.active = false
@mezcla_window.active = false
@info_window.visible = true
@info_window.set_info (resultado)
end
end
class Window_Info < Window_Base
def initialize
super (0, 0, 320, 128)
self.contents = Bitmap.new (width - 32, height - 32)
self.contents.font.size = 20
end
#--------------------------------------------------------------------------
def set_info (info = [])
self.contents.clear
# self.contents.fill_rect (0, 0, self.width, self.height, Color.new (0, 0, 0, 0))
if info.empty?
txt = "Combinación equivocada"
self.contents.draw_text (0, 0, self.width - 32, 32, txt, 1)
txt = "Has perdido los ingredientes"
self.contents.draw_text (0, 48, self.width - 32, 32, txt, 1)
return
end
resultados = {}
for item in info
if resultados.has_key? (item)
resultados[item] += 1
else
resultados[item] = 1
end
end
self.height = resultados.keys.size * 32 + 32 + 32 + 16
self.contents = Bitmap.new (width - 32, height - 32)
txt = "Has obtenido:"
self.contents.draw_text (0, 0, self.width - 32, 32, txt, 1)
for i in 0...resultados.keys.size
item_id = resultados.keys[i]
item = $data_items[item_id]
number = resultados[item_id]
x = 0
y = 32 + 16 + 32 * i
bitmap = RPG::Cache.icon(item.icon_name)
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
end
end
#--------------------------------------------------------------------------
def draw_item(data, pos)
end
#--------------------------------------------------------------------------
end
class Window_Inst < Window_Base
def initialize
super (0, 0, 320, 96)
self.contents = Bitmap.new (width - 32, height - 32)
refresh
end
def refresh
self.contents.clear
self.contents.draw_text (0, 0, self.width - 32, 32, "A: Vaciar")
self.contents.draw_text (0, 32, self.width - 32, 32, "Z: Mezclar")
end
end
#==============================================================================
# â– Window_Item
#------------------------------------------------------------------------------
class Window_Mezcla < Window_Selectable
#--------------------------------------------------------------------------
def initialize
super(0, 0, 320, 320)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
@items = {}
@column_max = 1
refresh
self.index = 0
end
#--------------------------------------------------------------------------
def añadir_ingrediente (item)
if @items[item].nil?
@items[item] = 1
else
@items[item] += 1
end
end
#--------------------------------------------------------------------------
def quitar_ingrediente
@items[item] -= 1
if @items[item] == 0
@items.delete (item)
end
end
#--------------------------------------------------------------------------
def refresh
self.contents.clear
@item_max = @items.keys.size
for i in 0...@items.keys.size
if not @items.keys[i].nil?
draw_item(@items.keys[i], i)
end
end
end
#--------------------------------------------------------------------------
def draw_item(data, pos)
item = $data_items[data]
number = @items[item.id]
x = 0
y = 32 * pos
bitmap = RPG::Cache.icon(item.icon_name)
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
end
#--------------------------------------------------------------------------
def items
items = []
for item in @items.keys
for g in 1..@items[item]
items.push (item)
end
end
return items
end
#--------------------------------------------------------------------------
def item
return @items.keys[self.index]
end
#--------------------------------------------------------------------------
end
#==============================================================================
# â– Window_Item
#------------------------------------------------------------------------------
class Window_Items < Window_Selectable
#--------------------------------------------------------------------------
def initialize
super(0, 0, 320, 416)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
@column_max = 1
refresh
self.index = 0
end
#--------------------------------------------------------------------------
def refresh
self.contents.clear
@data = []
for i in 1...$data_items.size
if $game_party.item_number(i) > 0 and
$data_items[i].element_set.include? ($atr_ingrediente)
@data.push($data_items[i])
end
end
@item_max = @data.size
if @item_max > 0
for i in 0...@data.size
draw_item(@data[i], i) if not @data[i].nil?
end
end
end
#--------------------------------------------------------------------------
def draw_item(data, pos)
item = data
number = $game_party.item_number(item.id)
x = 0
y = 32 * pos
bitmap = RPG::Cache.icon(item.icon_name)
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
end
#--------------------------------------------------------------------------
def item
return @data[self.index]
end
#--------------------------------------------------------------------------
end
-Instrucciones · Pegar encima de main. · Para ir a la pantalla de alquimia usa lo siguiente en un llamar script: $scene = Scene_Alquimia.new. · Elige la id del atributo que señala que un objeto es utilizable para combinar. · Edita la parte editable y crea las fórmulas posibles. -creditos Alnain
|
|
#26
16-dic-2008, 00:11
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
Lista Actualizada.. Gracias por Aportar ^^......
|
|
#27
18-dic-2008, 02:19
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
NOMBRE: Bonus de batalla
VERSIÓN: 1.0 RPGMAKER: vx rgss2 Descripción: Este script se basa en el sistema de Bonus de Batalla de Star Ocean 3. Cuando se rellena el indicador bonus con ciertas acciones como usar una habilidad o matar a un enemigo, el grupo entra en el modo Bonus de Batalla y gana bonus mientras esté lleno el indicador. El bonus puede detenerse si un miembro del grupo muere o es alcanzado por un golpe crítico. Screen:  Script:
Spoiler
Código:
#==============================================================================
# ** Bonus de Batalla
#------------------------------------------------------------------------------
# © Dargor, 2008
# 09/08/08
# Versión 1.0
#------------------------------------------------------------------------------
# HISTORIAL DE LA VERSIÓN:
# - 1.0 (09/08/08), Lanzamiento inicial
#------------------------------------------------------------------------------
# INTRODUCCIÓN:
# Este script se basa en el sistema de Bonus de Batalla de Star Ocean 3.
# Cuando se rellena el indicador bonus con ciertas acciones como
# usar una habilidad o matar a un enemigo, el grupo entra en el
# modo Bonus de Batalla y gana bonus mientras esté lleno el indicador.
# El bonus puede detenerse si un miembro del grupo muere o es alcanzado
# por un golpe crítico.
#------------------------------------------------------------------------------
# INSTRUCCIONES:
# - Coloca este script sobre Main
# - Edita las constantes en el módulo Bonus_Battles
#------------------------------------------------------------------------------
# NOTAS:
# - Este script solo soporta 4 tipos de bonus
# 1) Doble Oro
# 2) Doble EXP
# 3) Aumenta la probabilidad de obtener objeto
# 4) Aumenta la probabilidad de golpes preventivos
#==============================================================================
# Vocabulario
Vocab::BonusBattle = '¡BONUS DE BATALLA!'
#==============================================================================
# ** Módulo de Configuración del Bonus de Batalla
#==============================================================================
module Bonus_Battles
# La tasa máxima (en porcentaje) que puede alcanzar el indicador
Max_Rate = 300
# La cantidad máxima de puntos que se necesitan para llenar el indicador
Gauge_Max = 100
# Colores del indicador
Gauge_Color_1 = 29
Gauge_Color_2 = 28
Back_Color = 19
# Tiempo (en segundos) antes de que el bonus caiga
Decrease_Time = 2
# Efectos de sonido
Gauge_Filled_SE = 'Heal1'
Gauge_Break_SE = 'Battle2'
Bonus_Battle_ME = 'Fanfare1'
Play_Bonus_Battle_ME = false
# Puntos de Bonus ganados
Attack_Points = 1
Skill_Points = 2
Critical_Points = 4
Kill_Points = 8
# Ganar bonus automáticamente en Bonus de Batalla
Auto_Gain_Bonus = true
# Orden de bonus auto-ganado
Auto_Order = [1,3,4,2]
# Gana un bonus cada X batallas encadenadas
# (Sólo funciona si Auto_Gain_Bonus = true)
Bonus_Chain = 5
# Multiplicador Preventivo (Cuando el grupo tiene el Bonus Preventivo)
# Los preventivos/por sorpresa originales de VX dependen del nivel medio
# de agilidad. Si la media de agilidad del grupo es mayor que la media
# de agilidad del equipo enemigo:
# Probabilidad Preventivo = 5%, Probabilidad por Sorpresa = 3%
# Si la media de agilidad del enemigo es mayor que la media
# de agilidad del grupo:
# Probabilidad Preventivo = 3%, Probabilidad por Sorpresa = 5%
Preemptive_Multiplier = 4
end
#==============================================================================
# ** Sonido
#------------------------------------------------------------------------------
# Este módulo reproduce efectos de sonido. Obtiene los efectos especificados
# en la base de datos desde $data_system, y los reproduce.
#==============================================================================
module Sound
# Indicador de Bonus de Batalla Vacío
def self.play_gauge_break
se = RPG::SE.new(Bonus_Battles::Gauge_Break_SE)
se.play
end
# Indicador de Bonus de Batalla Relleno
def self.play_gauge_filled
se = RPG::SE.new(Bonus_Battles::Gauge_Filled_SE)
se.play
end
end
#==============================================================================
# ** SRPG::Enemigo::DejarObjeto
#==============================================================================
module RPG
class Enemy
class DropItem
#------------------------------------------------------------------------
# * Denominador
#------------------------------------------------------------------------
def denominator
if $game_party.increase_items?
return @denominator / 2
else
return @denominator
end
end
end
end
end
#==============================================================================
# ** Game_Unit
#------------------------------------------------------------------------------
# This class handles units. It's used as a superclass of the Game_Party and
# Game_Troop classes.
#==============================================================================
class Game_Unit
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def total_agi
result = 0
for member in members
result += member.agi
end
return result
end
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_Party
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :bonus_battles
attr_accessor :bonus_gauge
attr_accessor :last_bonus_gauge
attr_accessor :battle_bonuses
attr_accessor :gauge_rate
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_gauge_party_initialize initialize
alias dargor_vx_bonus_gauge_party_average_agi average_agi
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
dargor_vx_bonus_gauge_party_initialize
@bonus_battles = 0
@bonus_gauge = 20
@battle_bonuses = []
@last_bonus_gauge = @bonus_gauge
@gauge_rate = 200
end
#--------------------------------------------------------------------------
# * Add Battle Bonus
#--------------------------------------------------------------------------
def add_battle_bonus(type)
return unless can_add_bonus?
if !@battle_bonuses.empty? &&
(Bonus_Battles::Auto_Gain_Bonus or type == 0)
auto_add_battle_bonus
else
@battle_bonuses << type
end
@battle_bonuses.sort!
@battle_bonuses.uniq!
end
#--------------------------------------------------------------------------
# * Auto Add Battle Bonus
#--------------------------------------------------------------------------
def auto_add_battle_bonus
for i in Bonus_Battles::Auto_Order
if !@battle_bonuses.include?(i)
@battle_bonuses << i
return
end
end
end
#--------------------------------------------------------------------------
# * Can Add Battle Bonus?
#--------------------------------------------------------------------------
def can_add_bonus?
if @battle_bonuses.size == 0
result = Integer(@bonus_gauge) >= Bonus_Battles::Gauge_Max
@bonus_gauge = [@bonus_gauge, Bonus_Battles::Gauge_Max].min
return result
elsif @bonus_battles > 0
result = @bonus_battles % Bonus_Battles::Bonus_Chain == 0
return result
end
return false
end
#--------------------------------------------------------------------------
# * Get Adjusted Gauge Rate
#--------------------------------------------------------------------------
def get_adjusted_gauge_rate
agi_total = [average_agi, $game_troop.average_agi]
agi_min = agi_total.min
agi_max = agi_total.max
difference = (agi_min * 100) / agi_max
if average_agi >= $game_troop.average_agi
difference -= 1 until difference % 10 == 0
rate = 100 - ((difference / 2) + ($game_party.members.size * 10))
else
difference += 1 until difference % 10 == 0
rate = 100 + ((difference / 2) + ($game_troop.members.size * 10))
end
rate = [[rate, Bonus_Battles::Max_Rate].min, 0].max
return rate
end
#--------------------------------------------------------------------------
# * Calculate Average Agility
#--------------------------------------------------------------------------
def average_agi
result = dargor_vx_bonus_gauge_party_average_agi
result *= 2 if increase_preemptive?
return result
end
#--------------------------------------------------------------------------
# * Increase Gold Bonus
#--------------------------------------------------------------------------
def increase_gold?
return @battle_bonuses.include?(1)
end
#--------------------------------------------------------------------------
# * Increase EXP Bonus
#--------------------------------------------------------------------------
def increase_exp?
return @battle_bonuses.include?(2)
end
#--------------------------------------------------------------------------
# * Increase Items Bonus
#--------------------------------------------------------------------------
def increase_items?
return @battle_bonuses.include?(3)
end
#--------------------------------------------------------------------------
# * Increase Preemptive Bonus
#--------------------------------------------------------------------------
def increase_preemptive?
return @battle_bonuses.include?(4)
end
end
#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# * ALias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battle_enemy_exp exp
alias dargor_vx_bonus_battle_enemy_gold gold
#--------------------------------------------------------------------------
# * Get Experience
#--------------------------------------------------------------------------
def exp
result = dargor_vx_bonus_battle_enemy_exp
result *= 2 if $game_party.increase_exp?
return result
end
#--------------------------------------------------------------------------
# * Get Gold
#--------------------------------------------------------------------------
def gold
result = dargor_vx_bonus_battle_enemy_gold
result *= 2 if $game_party.increase_gold?
return result
end
end
#==============================================================================
# ** Sprite_BonusGauge
#------------------------------------------------------------------------------
# This sprite is used to display the bonus gauge on the battle screen.
# It observes the $game_system bonus gauge variables and automatically
# changes sprite conditions.
#==============================================================================
class Sprite_BonusGauge < Sprite
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :rate_sprite
attr_accessor :chain_sprite
#--------------------------------------------------------------------------
# * Object Initialization
# viewport : viewport
#--------------------------------------------------------------------------
def initialize(viewport)
super(viewport)
self.bitmap = Bitmap.new(92, 268)
self.x = 544 - self.bitmap.width
self.y = 16
self.z = 200
# Create a seperate sprite for Bonus Rate
@rate_sprite = Sprite.new(viewport)
@rate_sprite.bitmap = Bitmap.new(88,24)
@rate_sprite.x = self.x
@rate_sprite.y = 264
@rate_sprite.z = self.z + 1
# Create a seperate sprite for Chain Battles
@chain_sprite = Sprite.new(viewport)
@chain_sprite.bitmap = Bitmap.new(128,24)
@chain_sprite.x = self.x
@chain_sprite.y = 0
@chain_sprite.z = self.z + 1
@last_color = text_color(0)
refresh
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
super
self.bitmap.dispose
@rate_sprite.dispose
@chain_sprite.dispose
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.bitmap.clear
@rate_sprite.bitmap.clear
@chain_sprite.bitmap.clear
self.bitmap.fill_rect(70,0,10,268,gauge_back_color)
$game_party.bonus_gauge = [$game_party.bonus_gauge, Bonus_Battles::Gauge_Max].min
bar_height = ($game_party.bonus_gauge * 264) / Bonus_Battles::Gauge_Max
bar_y = 264 - bar_height + 2
gc1 = bar_color_1
gc2 = bar_color_2
self.bitmap.gradient_fill_rect(72,bar_y,6,bar_height,gc1,gc2,true)
rate = $game_party.gauge_rate
case rate
when 0
color = knockout_color
when 10..49
color = crisis_color
else
color = Color.new(255,255,255)
end
if color != @last_color
@rate_sprite.flash(@last_color, 20 * 4)
end
@rate_sprite.bitmap.font.color = color
@rate_sprite.bitmap.draw_text(0,0,88,24,"#{rate}%",2)
if $game_party.bonus_battles > 0
chain = $game_party.bonus_battles
@chain_sprite.bitmap.font.color = text_color(0)
@chain_sprite.bitmap.draw_text(0,0,32,24,chain,2)
@chain_sprite.bitmap.font.color = system_color
@chain_sprite.bitmap.draw_text(0,0,88,24,"Cadena",2)
end
@last_color = color
if $game_party.bonus_gauge == Bonus_Battles::Gauge_Max &&
$game_party.last_bonus_gauge != Bonus_Battles::Gauge_Max
Sound.play_gauge_filled
self.flash(Color.new(255,255,255), 20 * 4)
end
if $game_party.bonus_gauge == 0 &&
$game_party.last_bonus_gauge != 0
Sound.play_gauge_break
self.flash(Color.new(255,255,255), 20 * 4)
end
$game_party.last_bonus_gauge = $game_party.bonus_gauge
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
@rate_sprite.update
$game_party.bonus_gauge = [$game_party.bonus_gauge, Bonus_Battles::Gauge_Max].min
if $game_party.bonus_gauge != @points
refresh
end
end
#--------------------------------------------------------------------------
# * Get Text Color
# n : Text color number (0-31)
#--------------------------------------------------------------------------
def text_color(n)
windowskin = Cache.system("Window")
x = 64 + (n % 8) * 8
y = 96 + (n / 8) * 8
return windowskin.get_pixel(x, y)
end
#--------------------------------------------------------------------------
# * Get System Text Color
#--------------------------------------------------------------------------
def system_color
return text_color(16)
end
#--------------------------------------------------------------------------
# * Get Crisis Text Color
#--------------------------------------------------------------------------
def crisis_color
return text_color(17)
end
#--------------------------------------------------------------------------
# * Get Knockout Text Color
#--------------------------------------------------------------------------
def knockout_color
return text_color(18)
end
#--------------------------------------------------------------------------
# * Get Gauge First Color
#--------------------------------------------------------------------------
def bar_color_1
return text_color(Bonus_Battles::Gauge_Color_1)
end
#--------------------------------------------------------------------------
# * Get Gauge Second Color
#--------------------------------------------------------------------------
def bar_color_2
return text_color(Bonus_Battles::Gauge_Color_2)
end
#--------------------------------------------------------------------------
# * Get Gauge Background Color
#--------------------------------------------------------------------------
def gauge_back_color
return text_color(Bonus_Battles::Back_Color)
end
end
#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
# This sprite is used to display battlers. It observes a instance of the
# Game_Battler class and automatically changes sprite conditions.
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battles_battler_make_attack_damage_value make_attack_damage_value
alias dargor_vx_bonus_battles_battler_skill_effect skill_effect
#--------------------------------------------------------------------------
# * Calculation of Damage From Normal Attack
# attacker : Attacker
# The results are substituted for @hp_damage
#--------------------------------------------------------------------------
def make_attack_damage_value(attacker)
dargor_vx_bonus_battles_battler_make_attack_damage_value(attacker)
if attacker.is_a?(Game_Actor)
if @critical
# Do not add points for critical hit if the hit kills the target.
# Instead, add points for killing the target.
unless @hp_damage >= self.hp
points = Bonus_Battles::Critical_Points
points *= $game_party.gauge_rate.to_f / 100
$game_party.bonus_gauge += points
# Gain bonus for filling the bonus gauge with a critical hit
$game_party.add_battle_bonus(3)
end
elsif @hp_damage > 0 or @mp_damage > 0
# Do not add points for hitting if the hit kills the target.
# Instead, add points for killing the target.
unless @hp_damage >= self.hp
points = Bonus_Battles::Attack_Points
points *= $game_party.gauge_rate.to_f / 100
$game_party.bonus_gauge += points
# Gain bonus for filling the bonus gauge with an attack
$game_party.add_battle_bonus(1)
end
end
else
# Break bonus gauge if hit by a critical
if @critical
$game_party.bonus_gauge = 0
$game_party.bonus_battles = 0
$game_party.battle_bonuses = []
end
end
end
#--------------------------------------------------------------------------
# * Apply Skill Effects
# user : Skill user
# skill : skill
#--------------------------------------------------------------------------
def skill_effect(user, skill)
dargor_vx_bonus_battles_battler_skill_effect(user, skill)
if user.is_a?(Game_Actor)
# Do not add points for using skill if the skill kills the target.
# Instead, add points for killing the target.
unless @hp_damage >= self.hp
points = Bonus_Battles::Skill_Points
points *= $game_party.gauge_rate.to_f / 100
$game_party.bonus_gauge += points
# Gain bonus for filling the bonus gauge with an skill
$game_party.add_battle_bonus(2)
end
end
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
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battles_actor_perform_collapse perform_collapse
#--------------------------------------------------------------------------
# * Perform Collapse
#--------------------------------------------------------------------------
def perform_collapse
dargor_vx_bonus_battles_actor_perform_collapse
if $game_temp.in_battle and dead?
$game_party.bonus_gauge = 0
$game_party.bonus_battles = 0
$game_party.battle_bonuses = []
end
end
end
#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battles_enemy_perform_collapse perform_collapse
#--------------------------------------------------------------------------
# * Perform Collapse
#--------------------------------------------------------------------------
def perform_collapse
dargor_vx_bonus_battles_enemy_perform_collapse
if $game_temp.in_battle and dead?
points = Bonus_Battles::Kill_Points
points *= $game_party.gauge_rate.to_f / 100
$game_party.bonus_gauge += points
# Gain bonus for filling the bonus gauge by killing an enemy
$game_party.add_battle_bonus(4)
end
end
end
#==============================================================================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
# This class brings together battle screen sprites. It's used within the
# Scene_Battle class.
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :bonus_gauge
#--------------------------------------------------------------------------
# * Create Picture Sprite
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battles_spriteset_create_pictures create_pictures
alias dargor_vx_bonus_battles_spriteset_dispose_pictures dispose_pictures
alias dargor_vx_bonus_battles_spriteset_update_pictures update_pictures
#--------------------------------------------------------------------------
# * Create Picture Sprite
#--------------------------------------------------------------------------
def create_pictures
dargor_vx_bonus_battles_spriteset_create_pictures
@bonus_gauge = Sprite_BonusGauge.new(@viewport2)
end
#--------------------------------------------------------------------------
# * Dispose of Picture Sprite
#--------------------------------------------------------------------------
def dispose_pictures
dargor_vx_bonus_battles_spriteset_dispose_pictures
@bonus_gauge.dispose
end
#--------------------------------------------------------------------------
# *Update Picture Sprite
#--------------------------------------------------------------------------
def update_pictures
dargor_vx_bonus_battles_spriteset_update_pictures
@bonus_gauge.update
end
end
#==============================================================================
# ** Window_BonusBattle
#------------------------------------------------------------------------------
# This window displays battle bonuses on the battle screen.
#==============================================================================
class Window_BonusBattle < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 0, 544, 160)
self.opacity = 0
self.openness = 0
create_back_sprite
refresh
end
#--------------------------------------------------------------------------
# * refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.size = 24
self.contents.font.color = crisis_color
self.contents.draw_text(0,0,504,WLH,Vocab::BonusBattle,1)
self.contents.font.size = 20
self.contents.font.color = normal_color
return if $game_party.battle_bonuses.size == 0
for i in 0...$game_party.battle_bonuses.size
bonus = $game_party.battle_bonuses[i]
x = i % 1 * 272
y = i / 1 * WLH
case bonus
when 1
text = 'Doble Oro'
when 2
text = 'Doble EXP'
when 3
text = 'Aumenta la probabilidad de encontrar objetos'
when 4
text = 'Aumenta la probabilidad de ataques preventivos'
end
self.contents.draw_text(x,y + WLH,504,WLH,text)
end
end
#--------------------------------------------------------------------------
# * Create Background Sprite
#--------------------------------------------------------------------------
def create_back_sprite
@back_sprite = Sprite.new
@back_sprite.bitmap = Cache.system("MessageBack")
@back_sprite.opacity = openness
@back_sprite.z = self.z - 1
end
#--------------------------------------------------------------------------
# * Dispose of Background Sprite
#--------------------------------------------------------------------------
def dispose_back_sprite
@back_sprite.dispose
end
#--------------------------------------------------------------------------
# * Update Background Sprite
#--------------------------------------------------------------------------
def update_back_sprite
@back_sprite.opacity = openness
@back_sprite.update
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
super
dispose_back_sprite
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
def update
super
update_back_sprite
end
end
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
# This is a superclass of all windows in the game.
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :opening
end
#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
# This class performs the map screen processing.
#==============================================================================
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battle_map_preemptive_or_surprise preemptive_or_surprise
#--------------------------------------------------------------------------
# * Determine Preemptive Strike and Surprise Attack Chance
#--------------------------------------------------------------------------
def preemptive_or_surprise
if $game_party.increase_preemptive?
actors_agi = $game_party.average_agi
enemies_agi = $game_troop.average_agi
if actors_agi >= enemies_agi
percent_preemptive = 5 * Bonus_Battles::Preemptive_Multiplier
percent_surprise = 3
else
percent_preemptive = 3 * Bonus_Battles::Preemptive_Multiplier
percent_surprise = 5
end
if rand(100) < percent_preemptive
$game_troop.preemptive = true
elsif rand(100) < percent_surprise
$game_troop.surprise = true
end
else
dargor_vx_bonus_battle_map_preemptive_or_surprise
end
end
end
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * Alias Listing
#--------------------------------------------------------------------------
alias dargor_vx_bonus_battles_battle_start start
alias dargor_vx_bonus_battles_battle_terminate terminate
alias dargor_vx_bonus_battles_battle_update_basic update_basic
alias dargor_vx_bonus_battles_battle_execute_action execute_action
#--------------------------------------------------------------------------
# * Start Processing
#--------------------------------------------------------------------------
def start
# Increase bonus battle count
if $game_party.bonus_gauge == Bonus_Battles::Gauge_Max
$game_party.bonus_battles += 1
end
# Auto-gain bonuses
$game_party.add_battle_bonus(0)
# Set gauge rate
$game_party.gauge_rate = $game_party.get_adjusted_gauge_rate
# Create bonus window
@bonus_window = Window_BonusBattle.new
@bonus_window.open if $game_party.bonus_battles > 0
@last_party_bonus = $game_party.battle_bonuses
dargor_vx_bonus_battles_battle_start
end
#--------------------------------------------------------------------------
# * Start Processing
#--------------------------------------------------------------------------
def terminate
dargor_vx_bonus_battles_battle_terminate
@bonus_window.dispose
end
#--------------------------------------------------------------------------
# * Basic Update Processing
# main : Call from main update method
#--------------------------------------------------------------------------
def update_basic(main = false)
@bonus_window.update
update_bonus_gauge # Update the bonus gauge
update_bonus_window # Update the bonus window
# Close the bonus window
if Input.trigger?(Input::C)
@bonus_window.close
end
# The usual
dargor_vx_bonus_battles_battle_update_basic(main)
end
#--------------------------------------------------------------------------
# * Frame Update (Bonus gauge)
#--------------------------------------------------------------------------
def update_bonus_gauge
if update_bonus_gauge?
$game_party.gauge_rate = [$game_party.gauge_rate -= 10, 0].max
@spriteset.bonus_gauge.refresh
end
end
#--------------------------------------------------------------------------
# * Frame Update (Bonus window)
#--------------------------------------------------------------------------
def update_bonus_window
if ($game_party.bonus_gauge == Bonus_Battles::Gauge_Max &&
$game_party.last_bonus_gauge != Bonus_Battles::Gauge_Max) or
($game_party.battle_bonuses != @last_party_bonus)
@bonus_window.refresh
@bonus_window.open
@bonus_me = RPG::ME.new
@bonus_me.name = Bonus_Battles::Bonus_Battle_ME
@bonus_me.play if Bonus_Battles::Play_Bonus_Battle_ME
if $game_party.battle_bonuses != @last_party_bonus
@last_party_bonus = $game_party.battle_bonuses
end
end
end
#--------------------------------------------------------------------------
# * Update Bonus Gauge?
#--------------------------------------------------------------------------
def update_bonus_gauge?
time = Bonus_Battles::Decrease_Time * 60
result = true
result &&= @party_command_window.active == false
result &&= @message_window.visible == false
result &&= Graphics.frame_count % time == 0
return result
end
end
Instrucciones: Pégalo encima de Main. Es editable, así que revisa el script para dejarlo a tu gusto. Lo probe y funciona al 100%
|
|
#28
22-dic-2008, 09:41
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
-Nombre Del Script:ccoa's weather script
-Version Del Script:0.1 -Rpg Maker:XP -Introducion: Aquí les dejo este fantástico script que les permitirá darle más realismo a sus juegos. Tiene 14 climas predeterminados y uno para configurar. -Caracteristicas: Pegar este script en una nueva clase encima de Main. el resto está contenido en el script. -Script:
Spoiler
Código:
#===========================
# ccoa's weather script
# Creditos a CCoa...
#Completamente traducido por "PrincipeDragon"
#===========================
#Nota: no se explicar como modificar el script, si no sabes como hacer, simplemente dejalo como estaba, Grax
#Un buen script del clima:
#Los Tipos de tiempo son:
#1 - la lluvia
#2 - la tormenta
#3 - la nieve
#4 - el granizo
#5 - la lluvia con el trueno y relámpago
#6 - las hojas cayentes (otoño)
#7 - volando las hojas (otoño)
#8 - las hojas revueltas (otoño)
#9 - las hojas cayentes (verde)
#10 - la lozanía de la cereza (el sakura) los pétalos
#11 - los pétalos de la rosa
#12 - las plumas
#13 - la lluvia de sangre
#14 - las chispas
#15 - el usuario definió
#
# Poder (Fuerza) del Clima:
# Este tiene que ser un numero entero que varie de 0-40. Ejemplo: 0- Ninguna fuerza,
#40-400 imagenes...
#
# Utilización del Scritps:
# Crea un evento y le das a LLamar Scripts y pones:
# $game_screen.weather(Tipo1-14, Poder 0-40, Color)
#
#Ejemplo: $game_screen.weather(11, 5, 0) Esto hara que se activo el tipo numero 11
#los pétalos de la rosa con muy poca fuerza...
#
#Sinceramnete no se decir para que sirve Color, algunas veces o simpre pongo 0, he igual
#funciona...
#
#Para desactivar el script solo tienes que eligir en el panerl de eventos la opcion
#de "Opciones de clima" y seleccionar Ninguno.
#
# Para usar Clima Definido por el Usuario (Si no entiendes ver Demo):
# Mire lo siguiente a continuación:
$WEATHER_UPDATE = false # las $WEATHER_IMAGES, si hanc cambiado
$WEATHER_IMAGES = [] # entre eso, va el nombre de la imagen que se va a mostrar
$WEATHER_X = 0 # el numero de pixeles que la iamgen se tiene que mover horizontalemente(Nº positivo = Derecho, Nº Negativo = Izquiero)
$WEATHER_Y = 0 # el numero de pixeles que la iamgen se tiene que mover verticalmente (Nº positivo = Abajo, Nº Negativo = Arriba)
$WEATHER_FADE = 0 # En cuento debe aparecer la imagen (0 = no aparece, 255 = intantaneamente)
$WEATHER_ANIMATED = false #Eleciones: Si(true) o No(false). La imagen debe ciclo a través de todas las imágenes
module RPG
class Weather
def initialize(viewport = nil)
@type = 0
@max = 0
@ox = 0
@oy = 0
@count = 0
@current_pose = []
@info = []
@countarray = []
make_bitmaps
# **** ccoa ****
for i in 1..500
sprite = Sprite.new(viewport)
sprite.z = 1000
sprite.visible = false
sprite.opacity = 0
@sprites.push(sprite)
@current_pose.push(0)
@info.push(rand(50))
@countarray.push(rand(15))
end
end
def dispose
for sprite in @sprites
sprite.dispose
end
@rain_bitmap.dispose
@storm_bitmap.dispose
@snow_bitmap.dispose
@hail_bitmap.dispose
@petal_bitmap.dispose
@blood_rain_bitmap.dispose
for image in @autumn_leaf_bitmaps
image.dispose
end
for image in @green_leaf_bitmaps
image.dispose
end
for image in @rose_bitmaps
image.dispose
end
for image in @feather_bitmaps
image.dispose
end
for image in @sparkle_bitmaps
image.dispose
end
for image in @user_bitmaps
image.dispose
end
$WEATHER_UPDATE = true
end
def type=(type)
return if @type == type
@type = type
case @type
when 1 # LLuvia
bitmap = @rain_bitmap
when 2 # Tormenta
bitmap = @storm_bitmap
when 3 # Nieve
bitmap = @snow_bitmap
when 4 # Granizo
bitmap = @hail_bitmap
when 5 # Lluvia mas trueno y relampago
bitmap = @rain_bitmap
@thunder = true
when 6 # las hojas del otoño (cayentes)
bitmap = @autumn_leaf_bitmaps[0]
when 7 # las hojas del otoño (soplando)
bitmap = @autumn_leaf_bitmaps[0]
when 8 # las hojas del otoño (revueltas)
bitmap = @autumn_leaf_bitmaps[0]
when 9 # las hojas verdes (cayéndose)
bitmap = @green_leaf_bitmaps[0]
when 10 # Petalos tipo Sakura
bitmap = @petal_bitmap
when 11 # Petalos Rojos
bitmap = @rose_bitmaps[0]
when 12 # feathers
bitmap = @feather_bitmaps[0]
when 13 # La lluvia de sangre
bitmap = @blood_rain_bitmap
when 14 # Chispas
bitmap = @sparkle_bitmaps[0]
when 15 # Definido por el Usuario
bitmap = @user_bitmaps[rand(@user_bitmaps.size)]
else
bitmap = nil
end
if @type != 5
@thunder = false
end
# **** ccoa ****
for i in 1..500
sprite = @sprites[i]
if sprite != nil
sprite.visible = (i <= @max)
sprite.bitmap = bitmap
end
end
end
def ox=(ox)
return if @ox == ox;
@ox = ox
for sprite in @sprites
sprite.ox = @ox
end
end
def oy=(oy)
return if @oy == oy;
@oy = oy
for sprite in @sprites
sprite.oy = @oy
end
end
def max=(max)
return if @max == max;
# **** ccoa ****
@max = [[max, 0].max, 500].min
for i in 1..500
sprite = @sprites[i]
if sprite != nil
sprite.visible = (i <= @max)
end
end
end
def update
return if @type == 0
for i in 1..@max
sprite = @sprites[i]
if sprite == nil
break
end
if @type == 1 or @type == 5 or @type == 13 # rain
sprite.x -= 2
sprite.y += 16
sprite.opacity -= 8
if @thunder and (rand(8000 - @max) == 0)
$game_screen.start_flash(Color.new(255, 255, 255, 255), 5)
Audio.se_play("Audio/SE/061-Thunderclap01") # Sonido que se usara como trueno y relampago
end
end
if @type == 2 # Tormenra
sprite.x -= 8
sprite.y += 16
sprite.opacity -= 12
end
if @type == 3 # Nieve
sprite.x -= 2
sprite.y += 8
sprite.opacity -= 8
end
if @type == 4 # Granizo
sprite.x -= 1
sprite.y += 18
sprite.opacity -= 15
end
if @type == 6 # las hojas del otoño cayentes
@count = rand(20)
if @count == 0
sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
end
sprite.x -= 1
sprite.y += 1
end
if @type == 7 # las hojas del otoño soplando
@count = rand(20)
if @count == 0
sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
end
sprite.x -= 10
sprite.y += (rand(4) - 2)
end
if @type == 8 # las hojas del otoños revueltes
@count = rand(20)
if @count == 0
sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
end
if @info[i] != 0
if @info[i] >= 1 and @info[i] <= 10
sprite.x -= 3
sprite.y -= 1
elsif @info[i] >= 11 and @info[i] <= 16
sprite.x -= 1
sprite.y -= 2
elsif @info[i] >= 17 and @info[i] <= 20
sprite.y -= 3
elsif @info[i] >= 21 and @info[i] <= 30
sprite.y -= 2
sprite.x += 1
elsif @info[i] >= 31 and @info[i] <= 36
sprite.y -= 1
sprite.x += 3
elsif @info[i] >= 37 and @info[i] <= 40
sprite.x += 5
elsif @info[i] >= 41 and @info[i] <= 46
sprite.y += 1
sprite.x += 3
elsif @info[i] >= 47 and @info[i] <= 58
sprite.y += 2
sprite.x += 1
elsif @info[i] >= 59 and @info[i] <= 64
sprite.y += 3
elsif @info[i] >= 65 and @info[i] <= 70
sprite.x -= 1
sprite.y += 2
elsif @info[i] >= 71 and @info[i] <= 81
sprite.x -= 3
sprite.y += 1
elsif @info[i] >= 82 and @info[i] <= 87
sprite.x -= 5
end
@info[i] = (@info[i] + 1) % 88
else
if rand(200) == 0
@info[i] = 1
end
sprite.x -= 5
sprite.y += 1
end
end
if @type == 9 # Hojas verdes
if @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @green_leaf_bitmaps.size
sprite.bitmap = @green_leaf_bitmaps[@current_pose[i]]
@countarray[i] = rand(15)
end
@countarray[i] = (@countarray[i] + 1) % 15
sprite.y += 1
end
if @type == 10 # petalos tipo sakura
if @info[i] < 25
sprite.x -= 1
else
sprite.x += 1
end
@info[i] = (@info[i] + 1) % 50
sprite.y += 1
end
if @type == 11 # Petalos Rosa (rojo)
@count = rand(20)
if @count == 0
sprite.bitmap = @rose_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @rose_bitmaps.size
end
if @info[i] % 2 == 0
if @info[i] < 10
sprite.x -= 1
else
sprite.x += 1
end
end
sprite.y += 1
end
if @type == 12 # Plumas
if @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @feather_bitmaps.size
sprite.bitmap = @feather_bitmaps[@current_pose[i]]
end
@countarray[i] = (@countarray[i] + 1) % 15
if rand(100) == 0
sprite.x -= 1
end
if rand(100) == 0
sprite.y -= 1
end
if @info[i] < 50
if rand(2) == 0
sprite.x -= 1
else
sprite.y -= 1
end
else
if rand(2) == 0
sprite.x += 1
else
sprite.y += 1
end
end
@info[i] = (@info[i] + 1) % 100
end
if @type == 14 # Chispas
if @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @sparkle_bitmaps.size
sprite.bitmap = @sparkle_bitmaps[@current_pose[i]]
end
@countarray[i] = (@countarray[i] + 1) % 15
sprite.y += 1
sprite.opacity -= 1
end
if @type == 15 # Definido por el usuario
if $WEATHER_UPDATE
update_user_defined
$WEATHER_UPDATE = false
end
if $WEATHER_ANIMATED and @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @user_bitmaps.size
sprite.bitmap = @user_bitmaps[@current_pose[i]]
end
@countarray[i] = (@countarray[i] + 1) % 15
sprite.x += $WEATHER_X
sprite.y += $WEATHER_Y
sprite.opacity -= $WEATHER_FADE
end
x = sprite.x - @ox
y = sprite.y - @oy
if sprite.opacity < 64 or x < -50 or x > 750 or y < -300 or y > 500
sprite.x = rand(800) - 50 + @ox
sprite.y = rand(800) - 200 + @oy
sprite.opacity = 255
end
end
end
def make_bitmaps
color1 = Color.new(255, 255, 255, 255)
color2 = Color.new(255, 255, 255, 128)
@rain_bitmap = Bitmap.new(7, 56)
for i in 0..6
@rain_bitmap.fill_rect(6-i, i*8, 1, 8, color1)
end
@storm_bitmap = Bitmap.new(34, 64)
for i in 0..31
@storm_bitmap.fill_rect(33-i, i*2, 1, 2, color2)
@storm_bitmap.fill_rect(32-i, i*2, 1, 2, color1)
@storm_bitmap.fill_rect(31-i, i*2, 1, 2, color2)
end
@snow_bitmap = Bitmap.new(6, 6)
@snow_bitmap.fill_rect(0, 1, 6, 4, color2)
@snow_bitmap.fill_rect(1, 0, 4, 6, color2)
@snow_bitmap.fill_rect(1, 2, 4, 2, color1)
@snow_bitmap.fill_rect(2, 1, 2, 4, color1)
@sprites = []
blueGrey = Color.new(215, 227, 227, 150)
grey = Color.new(214, 217, 217, 150)
lightGrey = Color.new(233, 233, 233, 250)
lightBlue = Color.new(222, 239, 243, 250)
@hail_bitmap = Bitmap.new(4, 4)
@hail_bitmap.fill_rect(1, 0, 2, 1, blueGrey)
@hail_bitmap.fill_rect(0, 1, 1, 2, blueGrey)
@hail_bitmap.fill_rect(3, 1, 1, 2, grey)
@hail_bitmap.fill_rect(1, 3, 2, 1, grey)
@hail_bitmap.fill_rect(1, 1, 2, 2, lightGrey)
@hail_bitmap.set_pixel(1, 1, lightBlue)
color3 = Color.new(255, 167, 192, 255) # Color Rosa Claro
color4 = Color.new(213, 106, 136, 255) # Color Rosa Oscuro
# Estos des colores de usan para los colores de losmpetalos de rosas tipo sakura y rojas.
@petal_bitmap = Bitmap.new(4, 4) #Esto crea un nuevo bitmap que es de 4 x 4 pixeles
@petal_bitmap.fill_rect(0, 3, 1, 1, color3) # esto hace un 1x1 "rectángulo" del pixel a los 0, 3 pixel de la imagen (la esquina izquierda superior es 0, 0)
@petal_bitmap.fill_rect(1, 2, 1, 1, color3)
@petal_bitmap.fill_rect(2, 1, 1, 1, color3)
@petal_bitmap.fill_rect(3, 0, 1, 1, color3)
@petal_bitmap.fill_rect(1, 3, 1, 1, color4)
@petal_bitmap.fill_rect(2, 2, 1, 1, color4)
@petal_bitmap.fill_rect(3, 1, 1, 1, color4)
brightOrange = Color.new(248, 88, 0, 255)
orangeBrown = Color.new(144, 80, 56, 255)
burntRed = Color.new(152, 0, 0, 255)
paleOrange = Color.new(232, 160, 128, 255)
darkBrown = Color.new(72, 40, 0, 255)
@autumn_leaf_bitmaps = []
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
# Aqui se dibuja el primero de de los bitmaps de la hoja 1
@autumn_leaf_bitmaps[0].set_pixel(5, 1, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(6, 1, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(7, 1, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(3, 2, orangeBrown)
@autumn_leaf_bitmaps[0].fill_rect(4, 2, 2, 1, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(6, 2, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(2, 3, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(3, 3, brightOrange)
@autumn_leaf_bitmaps[0].fill_rect(4, 3, 2, 1, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(1, 4, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(2, 4, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(3, 4, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(1, 5, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(2, 5, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(0, 6, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(1, 6, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(0, 7, paleOrange)
# Se dibuja el segundo bitmap de la hoja 1
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
@autumn_leaf_bitmaps[1].set_pixel(3, 0, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(7, 0, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(3, 1, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(4, 1, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(6, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(0, 2, paleOrange)
@autumn_leaf_bitmaps[1].set_pixel(1, 2, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(2, 2, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(3, 2, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(4, 2, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(5, 2, brightOrange)
@autumn_leaf_bitmaps[1].fill_rect(1, 3, 3, 1, orangeBrown)
@autumn_leaf_bitmaps[1].fill_rect(4, 3, 2, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(6, 3, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(2, 4, burntRed)
@autumn_leaf_bitmaps[1].fill_rect(3, 4, 3, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(6, 4, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(7, 4, darkBrown)
@autumn_leaf_bitmaps[1].set_pixel(1, 5, orangeBrown)
@autumn_leaf_bitmaps[1].fill_rect(2, 5, 2, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(4, 5, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(5, 5, burntRed)
@autumn_leaf_bitmaps[1].fill_rect(1, 6, 2, 1, brightOrange)
@autumn_leaf_bitmaps[1].fill_rect(4, 6, 2, 1, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(0, 7, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(5, 7, darkBrown)
# Se dibuja el tercero bitmap de la hoja 1
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
@autumn_leaf_bitmaps[2].set_pixel(7, 1, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(6, 2, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(7, 2, orangeBrown)
@autumn_leaf_bitmaps[2].set_pixel(5, 3, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(6, 3, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(4, 4, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(5, 4, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(6, 4, orangeBrown)
@autumn_leaf_bitmaps[2].fill_rect(2, 5, 2, 1, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(4, 5, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(5, 5, orangeBrown)
@autumn_leaf_bitmaps[2].set_pixel(1, 6, paleOrange)
@autumn_leaf_bitmaps[2].fill_rect(2, 6, 2, 1, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(4, 6, orangeBrown)
@autumn_leaf_bitmaps[2].set_pixel(0, 7, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(1, 7, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(2, 7, orangeBrown)
# Se dibuja el cuarto bitmap de la hoja 1
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
@autumn_leaf_bitmaps[3].set_pixel(3, 0, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(7, 0, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(3, 1, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(4, 1, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(6, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(0, 2, paleOrange)
@autumn_leaf_bitmaps[3].set_pixel(1, 2, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(2, 2, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(3, 2, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(4, 2, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(5, 2, brightOrange)
@autumn_leaf_bitmaps[3].fill_rect(1, 3, 3, 1, orangeBrown)
@autumn_leaf_bitmaps[3].fill_rect(4, 3, 2, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(6, 3, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(2, 4, burntRed)
@autumn_leaf_bitmaps[3].fill_rect(3, 4, 3, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(6, 4, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(7, 4, darkBrown)
@autumn_leaf_bitmaps[3].set_pixel(1, 5, orangeBrown)
@autumn_leaf_bitmaps[3].fill_rect(2, 5, 2, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(4, 5, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(5, 5, burntRed)
@autumn_leaf_bitmaps[3].fill_rect(1, 6, 2, 1, brightOrange)
@autumn_leaf_bitmaps[3].fill_rect(4, 6, 2, 1, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(0, 7, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(5, 7, darkBrown)
@green_leaf_bitmaps = []
darkGreen = Color.new(62, 76, 31, 255)
midGreen = Color.new(76, 91, 43, 255)
khaki = Color.new(105, 114, 66, 255)
lightGreen = Color.new(128, 136, 88, 255)
mint = Color.new(146, 154, 106, 255)
# 1ª parte del bimap de otro hoja
@green_leaf_bitmaps[0] = Bitmap.new(8, 8)
@green_leaf_bitmaps[0].set_pixel(1, 0, darkGreen)
@green_leaf_bitmaps[0].set_pixel(1, 1, midGreen)
@green_leaf_bitmaps[0].set_pixel(2, 1, darkGreen)
@green_leaf_bitmaps[0].set_pixel(2, 2, khaki)
@green_leaf_bitmaps[0].set_pixel(3, 2, darkGreen)
@green_leaf_bitmaps[0].set_pixel(4, 2, khaki)
@green_leaf_bitmaps[0].fill_rect(2, 3, 3, 1, midGreen)
@green_leaf_bitmaps[0].set_pixel(5, 3, khaki)
@green_leaf_bitmaps[0].fill_rect(2, 4, 2, 1, midGreen)
@green_leaf_bitmaps[0].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[0].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[0].set_pixel(6, 4, khaki)
@green_leaf_bitmaps[0].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[0].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[0].set_pixel(5, 5, khaki)
@green_leaf_bitmaps[0].set_pixel(6, 5, lightGreen)
@green_leaf_bitmaps[0].set_pixel(4, 6, midGreen)
@green_leaf_bitmaps[0].set_pixel(5, 6, darkGreen)
@green_leaf_bitmaps[0].set_pixel(6, 6, lightGreen)
@green_leaf_bitmaps[0].set_pixel(6, 7, khaki)
# 2ª parte del bimap de otro hoja
@green_leaf_bitmaps[1] = Bitmap.new(8, 8)
@green_leaf_bitmaps[1].fill_rect(1, 1, 1, 2, midGreen)
@green_leaf_bitmaps[1].fill_rect(2, 2, 2, 1, khaki)
@green_leaf_bitmaps[1].set_pixel(4, 2, lightGreen)
@green_leaf_bitmaps[1].fill_rect(2, 3, 2, 1, darkGreen)
@green_leaf_bitmaps[1].fill_rect(4, 3, 2, 1, lightGreen)
@green_leaf_bitmaps[1].set_pixel(2, 4, midGreen)
@green_leaf_bitmaps[1].set_pixel(3, 4, darkGreen)
@green_leaf_bitmaps[1].set_pixel(4, 4, khaki)
@green_leaf_bitmaps[1].fill_rect(5, 4, 2, 1, lightGreen)
@green_leaf_bitmaps[1].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[1].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[1].set_pixel(5, 5, khaki)
@green_leaf_bitmaps[1].set_pixel(6, 5, lightGreen)
@green_leaf_bitmaps[1].set_pixel(5, 6, darkGreen)
@green_leaf_bitmaps[1].fill_rect(6, 6, 2, 1, khaki)
# 3ª parte del bimap de otro hoja
@green_leaf_bitmaps[2] = Bitmap.new(8, 8)
@green_leaf_bitmaps[2].set_pixel(1, 1, darkGreen)
@green_leaf_bitmaps[2].fill_rect(1, 2, 2, 1, midGreen)
@green_leaf_bitmaps[2].set_pixel(2, 3, midGreen)
@green_leaf_bitmaps[2].set_pixel(3, 3, darkGreen)
@green_leaf_bitmaps[2].set_pixel(4, 3, midGreen)
@green_leaf_bitmaps[2].fill_rect(2, 4, 2, 1, midGreen)
@green_leaf_bitmaps[2].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[2].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[2].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[2].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[2].fill_rect(5, 5, 2, 1, khaki)
@green_leaf_bitmaps[2].fill_rect(4, 6, 2, 1, midGreen)
@green_leaf_bitmaps[2].set_pixel(6, 6, lightGreen)
@green_leaf_bitmaps[2].set_pixel(6, 7, khaki)
# 4ª parte del bimap de otro hoja
@green_leaf_bitmaps[3] = Bitmap.new(8, 8)
@green_leaf_bitmaps[3].fill_rect(0, 3, 1, 2, darkGreen)
@green_leaf_bitmaps[3].set_pixel(1, 4, midGreen)
@green_leaf_bitmaps[3].set_pixel(2, 4, khaki)
@green_leaf_bitmaps[3].set_pixel(3, 4, lightGreen)
@green_leaf_bitmaps[3].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[3].set_pixel(7, 4, midGreen)
@green_leaf_bitmaps[3].set_pixel(1, 5, darkGreen)
@green_leaf_bitmaps[3].set_pixel(2, 5, midGreen)
@green_leaf_bitmaps[3].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[3].set_pixel(4, 5, mint)
@green_leaf_bitmaps[3].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[3].set_pixel(6, 5, khaki)
@green_leaf_bitmaps[3].set_pixel(7, 5, midGreen)
@green_leaf_bitmaps[3].fill_rect(2, 6, 2, 1, midGreen)
@green_leaf_bitmaps[3].set_pixel(4, 6, lightGreen)
@green_leaf_bitmaps[3].set_pixel(5, 6, khaki)
@green_leaf_bitmaps[3].set_pixel(6, 6, midGreen)
# 5ª parte del bimap de otro hoja
@green_leaf_bitmaps[4] = Bitmap.new(8, 8)
@green_leaf_bitmaps[4].set_pixel(6, 2, midGreen)
@green_leaf_bitmaps[4].set_pixel(7, 2, darkGreen)
@green_leaf_bitmaps[4].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[4].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[4].set_pixel(2, 4, darkGreen)
@green_leaf_bitmaps[4].fill_rect(3, 4, 2, 1, khaki)
@green_leaf_bitmaps[4].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[4].set_pixel(6, 4, khaki)
@green_leaf_bitmaps[4].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[4].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[4].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[4].set_pixel(4, 5, mint)
@green_leaf_bitmaps[4].set_pixel(5, 5, midGreen)
@green_leaf_bitmaps[4].set_pixel(2, 6, darkGreen)
@green_leaf_bitmaps[4].fill_rect(3, 6, 2, 1, midGreen)
# 6ª parte del bimap de otro hoja
@green_leaf_bitmaps[5] = Bitmap.new(8, 8)
@green_leaf_bitmaps[5].fill_rect(6, 2, 2, 1, midGreen)
@green_leaf_bitmaps[5].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[5].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[5].set_pixel(3, 4, midGreen)
@green_leaf_bitmaps[5].set_pixel(4, 4, khaki)
@green_leaf_bitmaps[5].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[5].set_pixel(6, 4, mint)
@green_leaf_bitmaps[5].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[5].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[5].fill_rect(3, 5, 2, 1, mint)
@green_leaf_bitmaps[5].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[5].set_pixel(2, 6, midGreen)
@green_leaf_bitmaps[5].set_pixel(3, 6, khaki)
@green_leaf_bitmaps[5].set_pixel(4, 6, lightGreen)
# 7ª parte del bimap de otro hoja
@green_leaf_bitmaps[6] = Bitmap.new(8, 8)
@green_leaf_bitmaps[6].fill_rect(6, 1, 1, 2, midGreen)
@green_leaf_bitmaps[6].fill_rect(4, 2, 2, 1, midGreen)
@green_leaf_bitmaps[6].fill_rect(6, 2, 1, 2, darkGreen)
@green_leaf_bitmaps[6].fill_rect(3, 3, 2, 1, midGreen)
@green_leaf_bitmaps[6].set_pixel(5, 3, khaki)
@green_leaf_bitmaps[6].set_pixel(2, 4, midGreen)
@green_leaf_bitmaps[6].set_pixel(3, 4, khaki)
@green_leaf_bitmaps[6].set_pixel(4, 4, lightGreen)
@green_leaf_bitmaps[6].set_pixel(5, 4, midGreen)
@green_leaf_bitmaps[6].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[6].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[6].fill_rect(3, 5, 2, 1, midGreen)
@green_leaf_bitmaps[6].set_pixel(1, 6, darkGreen)
@green_leaf_bitmaps[6].set_pixel(2, 6, midGreen)
# 8ª parte del bimap de otro hoja
@green_leaf_bitmaps[7] = Bitmap.new(8, 8)
@green_leaf_bitmaps[7].set_pixel(6, 1, midGreen)
@green_leaf_bitmaps[7].fill_rect(4, 2, 3, 2, midGreen)
@green_leaf_bitmaps[7].set_pixel(3, 3, darkGreen)
@green_leaf_bitmaps[7].set_pixel(2, 4, darkGreen)
@green_leaf_bitmaps[7].set_pixel(3, 4, midGreen)
@green_leaf_bitmaps[7].fill_rect(4, 4, 2, 1, khaki)
@green_leaf_bitmaps[7].set_pixel(1, 5, darkGreen)
@green_leaf_bitmaps[7].set_pixel(2, 5, midGreen)
@green_leaf_bitmaps[7].fill_rect(3, 5, 2, 1, lightGreen)
@green_leaf_bitmaps[7].set_pixel(2, 6, midGreen)
@green_leaf_bitmaps[7].set_pixel(3, 6, lightGreen)
# 9ª parte del bimap de otro hoja
@green_leaf_bitmaps[8] = Bitmap.new(8, 8)
@green_leaf_bitmaps[8].fill_rect(6, 1, 1, 2, midGreen)
@green_leaf_bitmaps[8].fill_rect(4, 2, 2, 1, midGreen)
@green_leaf_bitmaps[8].fill_rect(6, 2, 1, 2, darkGreen)
@green_leaf_bitmaps[8].fill_rect(3, 3, 2, 1, midGreen)
@green_leaf_bitmaps[8].set_pixel(5, 3, khaki)
@green_leaf_bitmaps[8].set_pixel(2, 4, midGreen)
@green_leaf_bitmaps[8].set_pixel(3, 4, khaki)
@green_leaf_bitmaps[8].set_pixel(4, 4, lightGreen)
@green_leaf_bitmaps[8].set_pixel(5, 4, midGreen)
@green_leaf_bitmaps[8].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[8].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[8].fill_rect(3, 5, 2, 1, midGreen)
@green_leaf_bitmaps[8].set_pixel(1, 6, darkGreen)
@green_leaf_bitmaps[8].set_pixel(2, 6, midGreen)
# 10ª parte del bimap de otro hoja
@green_leaf_bitmaps[9] = Bitmap.new(8, 8)
@green_leaf_bitmaps[9].fill_rect(6, 2, 2, 1, midGreen)
@green_leaf_bitmaps[9].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[9].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[9].set_pixel(3, 4, midGreen)
@green_leaf_bitmaps[9].set_pixel(4, 4, khaki)
@green_leaf_bitmaps[9].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[9].set_pixel(6, 4, mint)
@green_leaf_bitmaps[9].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[9].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[9].fill_rect(3, 5, 2, 1, mint)
@green_leaf_bitmaps[9].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[9].set_pixel(2, 6, midGreen)
@green_leaf_bitmaps[9].set_pixel(3, 6, khaki)
@green_leaf_bitmaps[9].set_pixel(4, 6, lightGreen)
# 11ª parte del bimap de otro hoja
@green_leaf_bitmaps[10] = Bitmap.new(8, 8)
@green_leaf_bitmaps[10].set_pixel(6, 2, midGreen)
@green_leaf_bitmaps[10].set_pixel(7, 2, darkGreen)
@green_leaf_bitmaps[10].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[10].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[10].set_pixel(2, 4, darkGreen)
@green_leaf_bitmaps[10].fill_rect(3, 4, 2, 1, khaki)
@green_leaf_bitmaps[10].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[10].set_pixel(6, 4, khaki)
@green_leaf_bitmaps[10].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[10].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[10].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[10].set_pixel(4, 5, mint)
@green_leaf_bitmaps[10].set_pixel(5, 5, midGreen)
@green_leaf_bitmaps[10].set_pixel(2, 6, darkGreen)
@green_leaf_bitmaps[10].fill_rect(3, 6, 2, 1, midGreen)
# 12ª parte del bimap de otro hoja
@green_leaf_bitmaps[11] = Bitmap.new(8, 8)
@green_leaf_bitmaps[11].fill_rect(0, 3, 1, 2, darkGreen)
@green_leaf_bitmaps[11].set_pixel(1, 4, midGreen)
@green_leaf_bitmaps[11].set_pixel(2, 4, khaki)
@green_leaf_bitmaps[11].set_pixel(3, 4, lightGreen)
@green_leaf_bitmaps[11].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[11].set_pixel(7, 4, midGreen)
@green_leaf_bitmaps[11].set_pixel(1, 5, darkGreen)
@green_leaf_bitmaps[11].set_pixel(2, 5, midGreen)
@green_leaf_bitmaps[11].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[11].set_pixel(4, 5, mint)
@green_leaf_bitmaps[11].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[11].set_pixel(6, 5, khaki)
@green_leaf_bitmaps[11].set_pixel(7, 5, midGreen)
@green_leaf_bitmaps[11].fill_rect(2, 6, 2, 1, midGreen)
@green_leaf_bitmaps[11].set_pixel(4, 6, lightGreen)
@green_leaf_bitmaps[11].set_pixel(5, 6, khaki)
@green_leaf_bitmaps[11].set_pixel(6, 6, midGreen)
# 14ª parte del bimap de otro hoja
@green_leaf_bitmaps[12] = Bitmap.new(8, 8)
@green_leaf_bitmaps[12].set_pixel(1, 1, darkGreen)
@green_leaf_bitmaps[12].fill_rect(1, 2, 2, 1, midGreen)
@green_leaf_bitmaps[12].set_pixel(2, 3, midGreen)
@green_leaf_bitmaps[12].set_pixel(3, 3, darkGreen)
@green_leaf_bitmaps[12].set_pixel(4, 3, midGreen)
@green_leaf_bitmaps[12].fill_rect(2, 4, 2, 1, midGreen)
@green_leaf_bitmaps[12].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[12].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[12].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[12].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[12].fill_rect(5, 5, 2, 1, khaki)
@green_leaf_bitmaps[12].fill_rect(4, 6, 2, 1, midGreen)
@green_leaf_bitmaps[12].set_pixel(6, 6, lightGreen)
@green_leaf_bitmaps[12].set_pixel(6, 7, khaki)
@rose_bitmaps = []
brightRed = Color.new(255, 0, 0, 255)
midRed = Color.new(179, 17, 17, 255)
darkRed = Color.new(141, 9, 9, 255)
# El 1º de los bipmap de los petalos de Rosa
@rose_bitmaps[0] = Bitmap.new(3, 3)
@rose_bitmaps[0].fill_rect(1, 0, 2, 1, brightRed)
@rose_bitmaps[0].fill_rect(0, 1, 1, 2, brightRed)
@rose_bitmaps[0].fill_rect(1, 1, 2, 2, midRed)
@rose_bitmaps[0].set_pixel(2, 2, darkRed)
# El 2º de los bipmap de los petalos de Rosa
@rose_bitmaps[1] = Bitmap.new(3, 3)
@rose_bitmaps[1].set_pixel(0, 1, midRed)
@rose_bitmaps[1].set_pixel(1, 1, brightRed)
@rose_bitmaps[1].fill_rect(1, 2, 1, 2, midRed)
@feather_bitmaps = []
white = Color.new(255, 255, 255, 255)
# El 3º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(0, 2, white)
@feather_bitmaps[0].set_pixel(1, 2, grey)
@feather_bitmaps[0].set_pixel(2, 1, grey)
# El 4º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(0, 0, white)
@feather_bitmaps[0].set_pixel(0, 1, grey)
@feather_bitmaps[0].set_pixel(1, 2, grey)
# El 5º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(2, 0, white)
@feather_bitmaps[0].set_pixel(1, 0, grey)
@feather_bitmaps[0].set_pixel(0, 1, grey)
# El 6º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(2, 2, white)
@feather_bitmaps[0].set_pixel(2, 1, grey)
@feather_bitmaps[0].set_pixel(1, 0, grey)
@blood_rain_bitmap = Bitmap.new(7, 56)
for i in 0..6
@blood_rain_bitmap.fill_rect(6-i, i*8, 1, 8, darkRed)
end
@sparkle_bitmaps = []
lightBlue = Color.new(181, 244, 255, 255)
midBlue = Color.new(126, 197, 235, 255)
darkBlue = Color.new(77, 136, 225, 255)
# Ahora continuamos con el bitmap de las chispas, este es el primero
@sparkle_bitmaps[0] = Bitmap.new(7, 7)
@sparkle_bitmaps[0].set_pixel(3, 3, darkBlue)
# 2º bitmap de Chispas
@sparkle_bitmaps[1] = Bitmap.new(7, 7)
@sparkle_bitmaps[1].fill_rect(3, 2, 1, 3, darkBlue)
@sparkle_bitmaps[1].fill_rect(2, 3, 3, 1, darkBlue)
@sparkle_bitmaps[1].set_pixel(3, 3, midBlue)
# 3º bitmap de Chispas
@sparkle_bitmaps[2] = Bitmap.new(7, 7)
@sparkle_bitmaps[2].set_pixel(3, 1, darkBlue)
@sparkle_bitmaps[2].set_pixel(5, 1, darkBlue)
@sparkle_bitmaps[2].set_pixel(2, 2, midBlue)
@sparkle_bitmaps[2].set_pixel(4, 2, midBlue)
@sparkle_bitmaps[2].set_pixel(3, 3, lightBlue)
@sparkle_bitmaps[2].set_pixel(2, 4, midBlue)
@sparkle_bitmaps[2].set_pixel(4, 4, midBlue)
@sparkle_bitmaps[2].set_pixel(1, 5, darkBlue)
@sparkle_bitmaps[2].set_pixel(5, 5, darkBlue)
# 4º bitmap de Chispas
@sparkle_bitmaps[3] = Bitmap.new(7, 7)
@sparkle_bitmaps[3].fill_rect(3, 1, 1, 5, darkBlue)
@sparkle_bitmaps[3].fill_rect(1, 3, 5, 1, darkBlue)
@sparkle_bitmaps[3].fill_rect(3, 2, 1, 3, midBlue)
@sparkle_bitmaps[3].fill_rect(2, 3, 3, 1, midBlue)
@sparkle_bitmaps[3].set_pixel(3, 3, lightBlue)
# 5º bitmap de Chispas
@sparkle_bitmaps[4] = Bitmap.new(7, 7)
@sparkle_bitmaps[4].fill_rect(2, 2, 3, 3, midBlue)
@sparkle_bitmaps[4].fill_rect(3, 2, 1, 3, darkBlue)
@sparkle_bitmaps[4].fill_rect(2, 3, 3, 1, darkBlue)
@sparkle_bitmaps[4].set_pixel(3, 3, lightBlue)
@sparkle_bitmaps[4].set_pixel(1, 1, darkBlue)
@sparkle_bitmaps[4].set_pixel(5, 1, darkBlue)
@sparkle_bitmaps[4].set_pixel(1, 5, darkBlue)
@sparkle_bitmaps[4].set_pixel(5, 1, darkBlue)
# 6º bitmap de Chispas
@sparkle_bitmaps[5] = Bitmap.new(7, 7)
@sparkle_bitmaps[5].fill_rect(2, 1, 3, 5, darkBlue)
@sparkle_bitmaps[5].fill_rect(1, 2, 5, 3, darkBlue)
@sparkle_bitmaps[5].fill_rect(2, 2, 3, 3, midBlue)
@sparkle_bitmaps[5].fill_rect(3, 1, 1, 5, midBlue)
@sparkle_bitmaps[5].fill_rect(1, 3, 5, 1, midBlue)
@sparkle_bitmaps[5].fill_rect(3, 2, 1, 3, lightBlue)
@sparkle_bitmaps[5].fill_rect(2, 3, 3, 1, lightBlue)
@sparkle_bitmaps[5].set_pixel(3, 3, white)
# 7º bitmap de Chispas
@sparkle_bitmaps[6] = Bitmap.new(7, 7)
@sparkle_bitmaps[6].fill_rect(2, 1, 3, 5, midBlue)
@sparkle_bitmaps[6].fill_rect(1, 2, 5, 3, midBlue)
@sparkle_bitmaps[6].fill_rect(3, 0, 1, 7, darkBlue)
@sparkle_bitmaps[6].fill_rect(0, 3, 7, 1, darkBlue)
@sparkle_bitmaps[6].fill_rect(2, 2, 3, 3, lightBlue)
@sparkle_bitmaps[6].fill_rect(3, 2, 1, 3, midBlue)
@sparkle_bitmaps[6].fill_rect(2, 3, 3, 1, midBlue)
@sparkle_bitmaps[6].set_pixel(3, 3, white)
@user_bitmaps = []
update_user_defined
end
def update_user_defined
for image in @user_bitmaps
image.dispose
end
#Bitmap de Definido por el Usurio
for name in $WEATHER_IMAGES
@user_bitmaps.push(RPG::Cache.picture(name))
end
for sprite in @sprites
sprite.bitmap = @user_bitmaps[rand(@user_bitmaps.size)]
end
end
attr_reader :type
attr_reader :max
attr_reader :ox
attr_reader :oy
end
end
-Creditos: CCoa PrincipeDragon
|
|
#29
28-dic-2008, 02:57
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
-Nombre Del Script:batalla lateral
-Version Del Script:no se -Rpg Maker:XP bueno la verdad esque ami este scrip no me va me dice que se a colgado al momento de provarlo pero se los dejo aver si a ustedes le va para que me ayuden selos dejo exactamento como lo encontre XD Para empezar se deben crear dos nuevas clases la primera llamada: Animated_sprite que debe contener: Este scrip:
Spoiler
[
Código:
#==============================================================================
# * Animated_Sprite Scripted by: RPG
# editado por: cybersam
# traducido por: Dark_Buster_XYZ
#
# Quite el desmadre que no acupaba en mi script...
# lo demas es script de RPG... (aqui)
#
#------------------------------------------------------------------------------
# Una clase para Animated_sprite.
#==============================================================================
class Animated_Sprite < RPG::Sprite
#--------------------------------------------------------------------------
# - Variables de caso accesibles.
#--------------------------------------------------------------------------
attr_accessor :frames # Numero de cuadrosdeanimacion
attr_accessor :delay # tiempo entre cuadros (velocidad)
attr_accessor :frame_width # ancho de cadacuadro
attr_accessor :frame_height # alto de cada cuadro
attr_accessor :offset_x # Coordenada X para el primer cuadro
attr_accessor :offset_y # Coordenada Y para todos los cuadros
attr_accessor :current_frame # cuadro de animacion actual
attr_accessor :moving # se esta moviendo el sprite?
#--------------------------------------------------------------------------
# - Analiza un sprite animado
# puerto de vista : puerto de vista del sprite
#--------------------------------------------------------------------------
def initialize(viewport = nil)
super(viewport)
@frame_width, @frame_height = 0, 0
change # un cambio basico para iniciar variables
@old = Graphics.frame_count # parael metodo de retarzo
@goingup = true # Incrementando animacion? (if @rm2k_mode is true)
@once = false # la animacion solo se reproduce una vez?
@animated = true # suele parar la animacion si @once es true
end
#--------------------------------------------------------------------------
# Comentario por RPG
# - Cambia la fuente (cambia la animacion)
# frames : Numero de cuadros
# delay : retarzo del cuadro, controla la velocidad
# offx : Coordenada X para el cuadro inicial
# offy : Coordenada y para todos los cuadros
# startf : Cuadro en que inicialaanimacion
# once : la animacion se reproduce una vez?
# rm2k_mode : modelo de animacion: 1-2-3-2 si es true, 1-2-3-1 si es false
#
# Comentario por cybersam
#
# el rm2k_mode ya no esta...
#--------------------------------------------------------------------------
def change(frames = 0, delay = 0, offx = 0, offy = 0,
startf = 0, once = false)
@frames = frames
@delay = delay
@offset_x, @offset_y = offx, offy
@current_frame = startf
@once = once
x = @current_frame * @frame_width + @offset_x
self.src_rect = Rect.new(x, @offset_y, @frame_width, @frame_height)
@goingup = true
@animated = true
end
#--------------------------------------------------------------------------
# - Actualizar animacion y movimiento
#--------------------------------------------------------------------------
def update
super
if self.bitmap != nil and delay(@delay) and @animated
x = @current_frame * @frame_width + @offset_x
self.src_rect = Rect.new(x, @offset_y, @frame_width, @frame_height)
@current_frame = (@current_frame + 1) unless @frames == 0
@animated = false if @current_frame == @frames and @once
@current_frame %= @frames
end
end
#--------------------------------------------------------------------------
# - Move el sprite
# x : Coordenada X para el punto de destino
# y : Coordenada Y para el punto de destinot
# speed : velocidad de animacion (0 = retrazado, 1+ = rapido)
# delay : movimiento retrazado si la velocidad es = 0
#--------------------------------------------------------------------------
def move(x, y, speed = 1, delay = 0)
@destx = x
@desty = y
@move_speed = speed
@move_delay = delay
@move_old = Graphics.frame_count
@moving = true
end
#--------------------------------------------------------------------------
# - Mueve el sprite a destx y desty
#--------------------------------------------------------------------------
def update_move
return unless @moving
movinc = @move_speed == 0 ? 1 : @move_speed
if Graphics.frame_count - @move_old > @move_delay or @move_speed != 0
self.x += movinc if self.x < @destx
self.x -= movinc if self.x > @destx
self.y += movinc if self.y < @desty
self.y -= movinc if self.y > @desty
@move_old = Graphics.frame_count
end
if @move_speed > 1 # Checasi el Sprite no pude llegar a su destino
self.x = @destx if (@destx - self.x).abs % @move_speed != 0 and
(@destx - self.x).abs <= @move_speed
self.y = @desty if (@desty - self.y).abs % @move_speed != 0 and
(@desty - self.y).abs <= @move_speed
end
if self.x == @destx and self.y == @desty
@moving = false
end
end
#--------------------------------------------------------------------------
# - Pausa la animacion, pero lo sigue actualizando
# frames : numero de cuadros
#--------------------------------------------------------------------------
def delay(frames)
update_move
if (Graphics.frame_count - @old >= frames)
@old = Graphics.frame_count
return true
end
return false
end
end
y debajo de esta la segunda llamada: Battle_animation quer debe contener Este otro scrip:
Spoiler
Código:
#===============================================================================
#
# Full Animated Side View Battle System (CBS) (v2.5) by cybersam
#
#===============================================================================
#
# y arrancamos!!!...
# esto hace el script muy fácil de ejecutar
# solamente añaden una nueva clase sobre "Main"
# e insertan esta cosa rara ahi
#
# como pueden ver que el scrip de cambio de sprite es del script
# japones entonces los créditos van para ellos ....
# lo edite un poco para que mostrara mas sprites y animaciones
# y añadi unaque otra cosita ...
# las siguiente es el movimiento de jugador...
#
#
#
# conseguí el script cambi battler en el scrip japones...
# los créditos de esto van al tipo que hizo esto...
#
# XRXS11. ver.0
#
# desde este instante no mas scrip japones ...
# no mas credito a ellos...
# pero le dejaré aquí ya que esto me ayudó mucho...
#
#
# como para las ideas ... missy me dio ideas realmente buenas
# que me ayudaron un chorro cuando no hallaba el rollo a algunos de estos rasgos...
#
# un credito mas que mencionar...
# es un scriptde RPG...
# no todo aqui...
# pero lo veras en los comentarios de script
#
#-------------------------------------------------------------------------------
#
# ok... desde que uso el movement script de RPG...
# hubo muchos cambios...
#
# cuando mires el script encontraras lineascomo: "pose(n)" o "enemy_pose(n)"
# desdeque quize que mis sprites tuvieran diferentes sprites...
# agregue una opcion a esto...
# si escribe un numero despues de "n" (la "n" significa el sprite que se
# esta usando)
# fo example 8... ("pose(4, 8)") esto le dira al escrip quela animacion 4
# tiene 8 cuadros...
# pose se usa con el juagador... y enemy_pose para el enemigo...
# use mis viejos numeros de sprite... (esta vezen solo un sprite...)
#
# esplicacion de las animaciones... (los digitos)
#
#
# 0 = mover (durante la pelea)
# 1 = inmovil
# 2 = defenza
# 3 = golpe (ser atacado)
# 4 = ataque
# 5 = habilidad
# 6 = muerte
# 7 = pose de victoria... idea de RPG....
#
#
# por su puesto este solo es el comienzo...
# se pueden agragar masanimaciones...
# pero por ahora es suficiente...
#
# mucho se cambio... y parece que ya quedo...
# por supuesto nesesita ser refinado porti para que se adecue a tu juego...
#
#
#-------------------------------------------------------------------------------
class Game_Actor < Game_Battler
# no nesitas cambiar al actordel juego para que funcione
# en la batalla...
# esto lo hace por ti... ^-^
def screen_x
if self.index != nil
return self.index * 40 + 460
else
return 0
end
end
def screen_y
return self.index * 20 + 220
end
def screen_z
if self.index != nil
return self.index
else
return 0
end
end
end
class Spriteset_Battle
#desmadre de RPG...
attr_accessor :actor_sprites
attr_accessor :enemy_sprites
# acaba aqui... ^-^
def initialize
@viewport0 = Viewport.new(0, 0, 640, 480)
@viewport1 = Viewport.new(0, 0, 640, 480)
@viewport2 = Viewport.new(0, 0, 640, 480)
@viewport3 = Viewport.new(0, 0, 640, 480)
@viewport4 = Viewport.new(0, 0, 640, 480)
@viewport2.z = 101
@viewport3.z = 200
@viewport4.z = 5000
@battleback_sprite = Sprite.new(@viewport0)
# arreglo para enemigos... para que no ataquen al incorrecto...
# lo arregle hace mucho pero de todos modos lo comento
# pa que sepan de eso... ^-^''
@enemy_sprites = []
for enemy in $game_troop.enemies#.reverse
@enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
end
@actor_sprites = []
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@actor_sprites.push(Sprite_Battler.new(@viewport2))
@weather = RPG::Weather.new(@viewport0)
@picture_sprites = []
for i in 51..100
@picture_sprites.push(Sprite_Picture.new(@viewport3,
$game_screen.pictures[i]))
end
@timer_sprite = Sprite_Timer.new
update
end
def dispose
if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap.dispose
end
@battleback_sprite.dispose
for sprite in @enemy_sprites + @actor_sprites
sprite.dispose
end
@weather.dispose
for sprite in @picture_sprites
sprite.dispose
end
@timer_sprite.dispose
@viewport0.dispose
@viewport1.dispose
@viewport2.dispose
@viewport3.dispose
@viewport4.dispose
end
def update
# esto hace que el personaje active tenga prioridad... (por Missy)
@viewport1.z = 50 and @viewport2.z = 51 if $actor_on_top == true
@viewport1.z = 51 and @viewport2.z = 50 if $actor_on_top == false
@actor_sprites[0].battler = $game_party.actors[0]
@actor_sprites[1].battler = $game_party.actors[1]
@actor_sprites[2].battler = $game_party.actors[2]
@actor_sprites[3].battler = $game_party.actors[3]
if @battleback_name != $game_temp.battleback_name
@battleback_name = $game_temp.battleback_name
if @battleback_sprite.bitmap != nil
@battleback_sprite.bitmap.dispose
end
@battleback_sprite.bitmap = RPG::Cache.battleback(@battleback_name)
@battleback_sprite.src_rect.set(0, 0, 640, 480)
if @battleback_sprite.bitmap.height == 320
@battleback_sprite.zoom_x = 1.5
@battleback_sprite.zoom_y = 1.5
@battleback_sprite.x = 320
@battleback_sprite.y = 480
@battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
@battleback_sprite.oy = @battleback_sprite.bitmap.height
else
@battleback_sprite.x = 0
@battleback_sprite.y = 0
@battleback_sprite.ox = 0
@battleback_sprite.oy = 0
@battleback_sprite.zoom_x = 1
@battleback_sprite.zoom_y = 1
end
end
for sprite in @enemy_sprites + @actor_sprites
sprite.update
end
@weather.type = $game_screen.weather_type
@weather.max = $game_screen.weather_max
@weather.update
for sprite in @picture_sprites
sprite.update
end
@timer_sprite.update
@viewport0.tone = $game_screen.tone
@viewport0.ox = $game_screen.shake
@viewport4.color = $game_screen.flash_color
@viewport0.update
@viewport1.update
@viewport2.update
@viewport4.update
end
end
#==============================================================================
# Sprite Battler para el sistema de batalla lateral
#==============================================================================
# aqui haces animaciones y esas cosas...
# se que no es la mejor manera...
# pero fue la primera funcional que encontre....
# estonesestia cierto conocimiento de como funcionana las animaciones...
# si deseas cambiar algo...
# no lo explicare mucho por que es facil si sabes que hacer
# por otro lado creo quete tomara un pococ entenderlo, pero creo que quien
# de editar esto sabe queesta haciendo... ^-^
#
#
#
# aqui cambiare totalmente la clase "Sprite_Battler"...
# por lo que si cambiaste algo ahi tambien lo debes cambiar aqui
# (creo... que no lo probe... asi que te lo dejo a tu criterio)
# lo agregue lo marcare con: --> #
# lo que se tieneque explicar viene comentado...
# pero no completamente...
class Sprite_Battler < Animated_Sprite
attr_accessor :battler
attr_reader :index
attr_accessor :target_index
attr_accessor :frame_width
def initialize(viewport, battler = nil)
super(viewport)
@battler = battler
@pattern_b = 0 #
@counter_b = 0 #
@index = 0 #
# esto es parael estado de la animacion...
# nolocambies amenosque sepas lo que haces...
$noanimation = false
@frame_width, @frame_height = 64, 64
# esmpieza el sprite
@battler.is_a?(Game_Enemy) ? enemy_pose(1) : pose(1)
@battler_visible = false
if $target_index == nil
$target_index = 0
end
end
def index=(index) #
@index = index #
update #
end #
def dispose
if self.bitmap != nil
self.bitmap.dispose
end
super
end
def enemy #
$target_index += $game_troop.enemies.size
$target_index %= $game_troop.enemies.size
return $game_troop.enemies[$target_index] #
end #
def actor #
$target_index += $game_party.actors.size
$target_index %= $game_party.actors.size
return $game_party.actors[$target_index] #
end
#==============================================================================
# aqui hay un fragmento del scriptde RPG...
# solo cambie lineas desde aqui...
#
# aqui pudes agregar mas lineasde animacion... si tienes... ^-^
#==============================================================================
def pose(number, frames = 4)
case number
when 0 # correr
change(frames, 5, 0, 0, 0)
when 1 # inmovil
change(frames, 5, 0, @frame_height)
when 2 # defender
change(frames, 5, 0, @frame_height * 2)
when 3 # herido
change(frames, 5, 0, @frame_height * 3)
when 4 # ataque
change(frames, 5, 0, @frame_height * 4, 0, true)
when 5 # habilidad
change(frames, 5, 0, @frame_height * 5)
when 6 # muerte
change(frames, 5, 0, @frame_height * 6)
when 7 # victoria
change(frames, 5, 0, @frame_height * 7)
#when 8
# change(frames, 5, 0, @frame_height * 9)
# ...etc.
else
change(frames, 5, 0, 0, 0)
end
end
#--------------------------------------------------------------------------
# - Cambia la pose del enemigo
# numero : numero de la pose
#--------------------------------------------------------------------------
def enemy_pose(number ,enemy_frames = 4)
case number
when 0 # correr
change(enemy_frames, 5, 0, 0, 0)
when 1 # inmovil
change(enemy_frames, 5, 0, @frame_height)
when 2 # defender
change(enemy_frames, 5, 0, @frame_height * 2)
when 3 # herido
change(enemy_frames, 5, 0, @frame_height * 3)
when 4 # ataque
change(enemy_frames, 5, 0, @frame_height * 4, 0, true)
when 5 # habilidad
change(enemy_frames, 5, 0, @frame_height * 5)
when 6 # muerte
change(enemy_frames, 5, 0, @frame_height * 6)
when 7 # victoria
change(enemy_frames, 5, 0, @frame_height * 7)
# ...etc.
else
change(enemy_frames, 5, 0, 0, 0)
end
end
def default_pose
pose(1)
# aqui se cambia la pose de default si
# no tenemos mas del 75% de vida
# si PV es un poco bajo (- 25%)
if (@battler.hp * 100) /@battler.maxhp < 25
pose(9)
# si PV es bajo (- 50%)
elsif (@battler.hp * 100) /@battler.maxhp < 50
pose(9)
# si pv es muy bajo (- 75%)
elsif (@battler.hp * 100) /@battler.maxhp < 75
pose(9)
end
# y aqui cambiamos la animacion siel personaje esta
# envenenado, dormido, o similar...
# solo puse el dormido y el envenenado para provar...
if @battler.state?(3) # veneno
# cambia a la pose de dormido...
# (notengo muchos sprites asi que use la de defenza)
# puedes agregar mas sprites, incluse uno para cada estado...
pose(2)
elsif @battler.state?(7) #dormido
# cambia a envene nado
pose(6)
end
end
#==============================================================================
# fin del fracmento...
#==============================================================================
def update
super
if @battler == nil
self.bitmap = nil
loop_animation(nil)
return
end
if @battler.name != @battler_name
@battler.battler_hue != @battler_hue
@battler_hue = @battler.battler_hue
@battler_name = @battler.name
self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
@width = bitmap.width
@height = bitmap.height
self.ox = @frame_width / 2
self.oy = @frame_height
if @battler.dead? or @battler.hidden
self.opacity = 0
end
self.x = @battler.screen_x
self.y = @battler.screen_y
self.z = @battler.screen_z
end
if $noanimation == false
if @battler.damage == nil and
@battler.state_animation_id != @state_animation_id
@state_animation_id = @battler.state_animation_id
loop_animation($data_animations[@state_animation_id])
end
else
dispose_loop_animation
end
if @battler.is_a?(Game_Actor) and @battler_visible
if $game_temp.battle_main_phase
self.opacity += 3 if self.opacity < 255
else
self.opacity -= 3 if self.opacity > 207
end
end
if @battler.blink
blink_on
else
blink_off
end
unless @battler_visible
if not @battler.hidden and not @battler.dead? and
(@battler.damage == nil or @battler.damage_pop)
appear
@battler_visible = true
end
if not @battler.hidden and
(@battler.damage == nil or @battler.damage_pop) and
@battler.is_a?(Game_Actor)
appear
@battler_visible = true
end
end
if @battler_visible
if @battler.hidden
$game_system.se_play($data_system.escape_se)
escape
@battler_visible = false
end
if @battler.white_flash
whiten
@battler.white_flash = false
end
if @battler.animation_id != 0
animation = $data_animations[@battler.animation_id]
animation(animation, @battler.animation_hit)
@battler.animation_id = 0
end
if @battler.damage_pop
damage(@battler.damage, @battler.critical)
@battler.damage = nil
@battler.critical = false
@battler.damage_pop = false
end
if @battler.damage == nil and @battler.dead?
if @battler.is_a?(Game_Enemy)
$game_system.se_play($data_system.enemy_collapse_se)
collapse
@battler_visible = false
else
$game_system.se_play($data_system.actor_collapse_se) unless @dead
@dead = true
pose(6)
end
else
@dead = false
end
end #
end
end
#==============================================================================
# Scene_Battle Sistemade Batalla Lateral
#==============================================================================
class Scene_Battle
def update_phase4
case @phase4_step
when 1
update_phase4_step1
when 2
update_phase4_step2
when 3
update_phase4_step3
when 4
update_phase4_step4
when 5
update_phase4_step5
when 6
update_phase4_step6
when 7
update_phase4_step7
end
end
def update_phase4_step1
# Cambiala pose del actor a default
#if @active_battler.is_a?(Game_Actor)
# @spriteset.actor_sprites[@active_battler.index].default_pose
#end
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
@spriteset.actor_sprites[i].default_pose unless actor.dead?
end
@help_window.visible = false
if judge
return
end
if $game_temp.forcing_battler == nil
setup_battle_event
if $game_system.battle_interpreter.running?
return
end
end
if $game_temp.forcing_battler != nil
@action_battlers.delete($game_temp.forcing_battler)
@action_battlers.unshift($game_temp.forcing_battler)
end
if @action_battlers.size == 0
start_phase2
return
end
@animation1_id = 0
@animation2_id = 0
@common_event_id = 0
@active_battler = @action_battlers.shift
if @active_battler.index == nil
return
end
if @active_battler.hp > 0 and @active_battler.slip_damage?
@active_battler.slip_damage_effect
@active_battler.damage_pop = true
end
@active_battler.remove_states_auto
@status_window.refresh
@phase4_step = 2
end
def make_basic_action_result
if @active_battler.is_a?(Game_Actor)
$actor_on_top = true
elsif @active_battler.is_a?(Game_Enemy)
$actor_on_top = false
end
if @active_battler.current_action.basic == 0
#============================================================================
# EMPIEZAN LAS ARMAS...
#============================================================================
#
#======== DIFERENTES ARMAS CON DIFERENTES ANIMACIONES
#
# es massimple de lo que parece...
# si quiresagregar una animacion a un arma checa...
# y espero que descubras como funciona...
#
#
# si no...
# aqui esta como...
# primero...
# solo copia y pega "elseif @active_battler_enemy.weapon_id == ID..."
# justo después el último @weapon_sprite....
#
# El ID lo nesesitas chacaren tu base de datos y ver el numero antes de tu arma
# y ese el Id que nesesitas...
#
# lo mismova para el lado enemigo... ^-^
# normalmento los enemigosno acupan mas sprites para armas....
#
# si quieres usar mas... esntonces reemplaza "@weapon_sprite_enemy = 4"
# con estas lineas... (pero ocupas editarlas)
#
# if @active_battler.weapon_id == 1 # <-- numero ID del arma
# @weapon_sprite_enemy = 4 # <-- animacion de batalla
# elsif @active_battler.weapon_id == 5 # <-- numero ID del arma
# @weapon_sprite_enemy = 2 # <-- animacion de batalla
# elsif @active_battler.weapon_id == 9 # <-- numero ID del arma
# @weapon_sprite_enemy = 0 # <-- animacion de batalla
# elsif @active_battler.weapon_id == 13 # <-- numero ID del arma
# @weapon_sprite_enemy = 6 # <-- animacion de batalla
# else
# @weapon_sprite_enemy = 4
# end
#
#================================= FIN
if @active_battler.is_a?(Game_Actor)
if @active_battler.weapon_id == 1 # <-- numero ID del arma
@weapon_sprite = 4 # <-- animacion de batalla
elsif @active_battler.weapon_id == 5 # <-- numero ID del arma
@weapon_sprite = 2 # <-- animacion de batalla
elsif @active_battler.weapon_id == 9 # <-- numero ID del arma
@weapon_sprite = 0 # <-- animacion de batalla
elsif @active_battler.weapon_id == 13 # <-- numero ID del arma
@weapon_sprite = 6 # <-- animacion de batalla
else
@weapon_sprite = 4
end
# seccion del enemigo aqui... ^-^
else# @active_battler.is_a?(Game_Enemy)
@weapon_sprite_enemy = 4
end
#
#=============================================================================
# Fin de las armas....
#=============================================================================
@animation1_id = @active_battler.animation1_id
@animation2_id = @active_battler.animation2_id
if @active_battler.is_a?(Game_Enemy)
if @active_battler.restriction == 3
target = $game_troop.random_target_enemy
elsif @active_battler.restriction == 2
target = $game_party.random_target_actor
else
index = @active_battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
end
#======== aqui se configuran movimientos y animaciones...
x = target.screen_x - 32
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(0)
@spriteset.enemy_sprites[@active_battler.index]\
.move(x, target.screen_y, 10)
#========= si abserbas la configuracion del script RPG
#========= que el toma el numero 40 para la velocidad de la animacion...
#========= y creoque es muy rapidoasi que lo baje a 10...
end
if @active_battler.is_a?(Game_Actor)
if @active_battler.restriction == 3
target = $game_party.random_target_actor
elsif @active_battler.restriction == 2
target = $game_troop.random_target_enemy
else
index = @active_battler.current_action.target_index
target = $game_troop.smooth_target_enemy(index)
end
#======= lo mismo para el jugador... ^-^
x = target.screen_x + 32
@spriteset.actor_sprites[@active_battler.index].pose(0)
@spriteset.actor_sprites[@active_battler.index]\
.move(x, target.screen_y, 10)
end
@target_battlers = [target]
for target in @target_battlers
target.attack_effect(@active_battler)
end
return
end
if @active_battler.current_action.basic == 1
if @active_battler.is_a?(Game_Actor)
@spriteset.actor_sprites[@active_battler.index].pose(2) #defenza
else
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(2) #defenza
end
@help_window.set_text($data_system.words.guard, 1)
return
end
if @active_battler.is_a?(Game_Enemy) and
@active_battler.current_action.basic == 2
@help_window.set_text("Escapar", 1)
@active_battler.escape
return
end
if @active_battler.current_action.basic == 3
$game_temp.forcing_battler = nil
@phase4_step = 1
return
end
if @active_battler.current_action.basic == 4
if $game_temp.battle_can_escape == false
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
update_phase2_escape
return
end
end
#--------------------------------------------------------------------------
# Accion de Habilidad...
#--------------------------------------------------------------------------
def make_skill_action_result
@skill = $data_skills[@active_battler.current_action.skill_id]
unless @active_battler.current_action.forcing
unless @active_battler.skill_can_use?(@skill.id)
$game_temp.forcing_battler = nil
@phase4_step = 1
return
end
end
@active_battler.sp -= @skill.sp_cost
@status_window.refresh
@help_window.set_text(@skill.name, 1)
#=============================================================================
# INICIAN LOS SPRITESDE HABILIDAD
#=============================================================================
# es lo mismo que en el de armas...
#============================================================================
# Animacion de batalla Battle_animation
#============================================================================
#
# para quien esta en esto por primera vez
# vean el script espero que sea facil deentender...
#
# el numero despues de "pose" es el IDde animacion... y es igual para las demas.
# si tienes una animacion de habilidad con mascuadros...
# solo insertael numaro de cuadros despues del primer numero...
# se ve asi.... "pose(5, 8)" <-- 5 es la animacion...
# 8 esel maximo de cuadros (quiere decir que tu animacion tiene 8 cuadros...) ^-^
if @active_battler.is_a?(Game_Actor)
if @skill.name == "Cura" # <-- nombre de la primer habilidad
@spriteset.actor_sprites[@active_battler.index].pose(5) # <-- numero del sprite
elsif @skill.name == "Cross Cut" # <-- nombre de la segunda habilidad
@spriteset.actor_sprites[@active_battler.index].pose(6) # <-- numero del sprite
elsif @skill.name == "Fuego" # <-- nombre de la tercer habilidad
@spriteset.actor_sprites[@active_battler.index].pose(6) # <-- numero del sprite
end
else
if @skill.name == "Cura" # <-- nombre de la primer habilidad
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(5) # <-- numero del sprite
elsif @skill.name == "Cross Cut" # <-- nombre de la segunda habilidad
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(6) # <-- numero del sprite
elsif @skill.name == "Fuego" # <-- nombre de la tercer habilidad
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(6) # <-- numero del sprite
end
end
#=============================================================================
# TERMINAN LAS HABILIDADES
#=============================================================================
@animation1_id = @skill.animation1_id
@animation2_id = @skill.animation2_id
@common_event_id = @skill.common_event_id
set_target_battlers(@skill.scope)
for target in @target_battlers
target.skill_effect(@active_battler, @skill)
end
end
#--------------------------------------------------------------------------
# Como usamos los items
#--------------------------------------------------------------------------
def make_item_action_result
# disculpen pero aqui no meti mano...
# por quenotengo sprite de uso de objetos....
# soloagregue el sprite "inmovil" aqui...
# cuando tenga mastiempo usare uno... ^-^
# es lo mismo que en los otros...
if @active_battler.is_a?(Game_Actor)
@spriteset.actor_sprites[@active_battler.index].pose(1)
else
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
end
@item = $data_items[@active_battler.current_action.item_id]
unless $game_party.item_can_use?(@item.id)
@phase4_step = 1
return
end
if @item.consumable
$game_party.lose_item(@item.id, 1)
end
@help_window.set_text(@item.name, 1)
@animation1_id = @item.animation1_id
@animation2_id = @item.animation2_id
@common_event_id = @item.common_event_id
index = @active_battler.current_action.target_index
target = $game_party.smooth_target_actor(index)
set_target_battlers(@item.scope)
for target in @target_battlers
target.item_effect(@item)
end
end
#==============================================================================
# otra vez.... un fracmento del scriptde RPG
#==============================================================================
# esto es parala pose de victoria...
def start_phase5
@phase = 5
$game_system.me_play($game_system.battle_end_me)
$game_system.bgm_play($game_temp.map_bgm)
exp = 0
gold = 0
treasures = []
for enemy in $game_troop.enemies
unless enemy.hidden
exp += enemy.exp
gold += enemy.gold
if rand(100) < enemy.treasure_prob
if enemy.item_id > 0
treasures.push($data_items[enemy.item_id])
end
if enemy.weapon_id > 0
treasures.push($data_weapons[enemy.weapon_id])
end
if enemy.armor_id > 0
treasures.push($data_armors[enemy.armor_id])
end
end
end
end
treasures = treasures[0..5]
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
$noanimation = true
@spriteset.actor_sprites[i].pose(7) unless actor.dead? # {=====}
if actor.cant_get_exp? == false
last_level = actor.level
actor.exp += exp
if actor.level > last_level
@status_window.level_up(i)
end
end
end
$game_party.gain_gold(gold)
for item in treasures
case item
when RPG::Item
$game_party.gain_item(item.id, 1)
when RPG::Weapon
$game_party.gain_weapon(item.id, 1)
when RPG::Armor
$game_party.gain_armor(item.id, 1)
end
end
@result_window = Window_BattleResult.new(exp, gold, treasures)
@phase5_wait_count = 100
end
#--------------------------------------------------------------------------
# actualizando el movimiento
# desde queRPG nolo comentaba... yo lo explicare...
#--------------------------------------------------------------------------
def update_phase4_step3
if @active_battler.current_action.kind == 0 and
@active_battler.current_action.basic == 0
# aqui... tenemos la animaciones de armas... para jugadores y enemigos
if @active_battler.is_a?(Game_Actor)
@spriteset.actor_sprites[@active_battler.index].pose(@weapon_sprite)
elsif @active_battler.is_a?(Game_Enemy)
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(@weapon_sprite_enemy)
end
end
if @animation1_id == 0
@active_battler.white_flash = true
else
@active_battler.animation_id = @animation1_id
@active_battler.animation_hit = true
end
@phase4_step = 4
end
def update_phase4_step4
# aqui para la animacion del golpe...
for target in @target_battlers
if target.is_a?(Game_Actor) and !@active_battler.is_a?(Game_Actor)
if target.guarding?
@spriteset.actor_sprites[target.index].pose(2)
else
@spriteset.actor_sprites[target.index].pose(3)
end
elsif target.is_a?(Game_Enemy) and !@active_battler.is_a?(Game_Enemy)
if target.guarding?
@spriteset.enemy_sprites[target.index].enemy_pose(2)
else
@spriteset.enemy_sprites[target.index].enemy_pose(3)
end
end
target.animation_id = @animation2_id
target.animation_hit = (target.damage != "Miss")
end
@wait_count = 8
@phase4_step = 5
end
def update_phase4_step5
if @active_battler.hp > 0 and @active_battler.slip_damage?
@active_battler.slip_damage_effect
@active_battler.damage_pop = true
end
@help_window.visible = false
@status_window.refresh
if @active_battler.is_a?(Game_Actor)
@spriteset.actor_sprites[@active_battler.index].pose(1)
else
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
end
for target in @target_battlers
if target.damage != nil
target.damage_pop = true
if @active_battler.is_a?(Game_Actor)
@spriteset.actor_sprites[@active_battler.index].pose(1)
else
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
end
end
end
@phase4_step = 6
end
#--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
#--------------------------------------------------------------------------
def update_phase4_step6
# aqui vemos si el jugador esta muerto y si es jugador o ememigo...
# estas lineas son para correrde regreso y la animacion inmovil....
if @active_battler.is_a?(Game_Actor) and !@active_battler.dead?
@spriteset.actor_sprites[@active_battler.index]\
.move(@active_battler.screen_x, @active_battler.screen_y, 20)
@spriteset.actor_sprites[@active_battler.index].pose(0)
elsif !@active_battler.dead?
@spriteset.enemy_sprites[@active_battler.index]\
.move(@active_battler.screen_x, @active_battler.screen_y, 20)
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(0)
end
for target in @target_battlers
if target.is_a?(Game_Actor) and !target.dead?
@spriteset.actor_sprites[target.index].pose(1)
elsif !target.dead?
@spriteset.enemy_sprites[target.index].enemy_pose(1)
end
end
$game_temp.forcing_battler = nil
if @common_event_id > 0
common_event = $data_common_events[@common_event_id]
$game_system.battle_interpreter.setup(common_event.list, 0)
end
@phase4_step = 7
end
def update_phase4_step7
# aqui vemos si el jugador esta muerto y si es jugador o ememigo...
# estas lineas son para correrde regreso y la animacion inmovil....
if @active_battler.is_a?(Game_Actor) and !@active_battler.dead?
@spriteset.actor_sprites[@active_battler.index].pose(1)
elsif !@active_battler.dead?
@spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
end
$game_temp.forcing_battler = nil
if @common_event_id > 0
common_event = $data_common_events[@common_event_id]
$game_system.battle_interpreter.setup(common_event.list, 0)
end
@phase4_step = 1
end
# y esta extra... wsin esto no funciona correctamente...
def update
if $game_system.battle_interpreter.running?
$game_system.battle_interpreter.update
if $game_temp.forcing_battler == nil
unless $game_system.battle_interpreter.running?
unless judge
setup_battle_event
end
end
if @phase != 5
@status_window.refresh
end
end
end
$game_system.update
$game_screen.update
if $game_system.timer_working and $game_system.timer == 0
$game_temp.battle_abort = true
end
@help_window.update
@party_command_window.update
@actor_command_window.update
@status_window.update
@message_window.update
@spriteset.update
if $game_temp.transition_processing
$game_temp.transition_processing = false
if $game_temp.transition_name == ""
Graphics.transition(20)
else
Graphics.transition(40, "Graphics/Transitions/" +
$game_temp.transition_name)
end
end
if $game_temp.message_window_showing
return
end
if @spriteset.effect?
return
end
if $game_temp.gameover
$scene = Scene_Gameover.new
return
end
if $game_temp.to_title
$scene = Scene_Title.new
return
end
if $game_temp.battle_abort
$game_system.bgm_play($game_temp.map_bgm)
battle_end(1)
return
end
if @wait_count > 0
@wait_count -= 1
return
end
# esto pausa la battalla mientras el personaje se mueve
for actor in @spriteset.actor_sprites
if actor.moving
return
end
end
# y esto es para el enemigo...
for enemy in @spriteset.enemy_sprites
if enemy.moving# and $game_system.animated_enemy
return
end
end
if $game_temp.forcing_battler == nil and
$game_system.battle_interpreter.running?
return
end
case @phase
when 1
update_phase1
when 2
update_phase2
when 3
update_phase3
when 4
update_phase4
when 5
update_phase5
end
end
#==============================================================================
# fin del fracmento
#==============================================================================
#------------------------------------------------------------------------------
# Scripted by: RPG
# editado por: cybersam
# traducido por: Dark_Buster_XYZ
#------------------------------------------------------------------------------
end
Ambos sobre main Por ejemplo: * Animated_sprite * Battle_animation * Main Para que funcione adecuadamente se deben poner en la carpeta Battlers los sprites detallados que vamos a usar, y que deben medir 64 x 64 cada cuadro de animacion y se aconseja que sean de 4 x minimo 7 ejemplo  con el mismo nombre del personaje y mirando al lado correcto esto es tanto para personajes como para enemigos Battlers para este Script: Pack 1 ScreenShots:  Bueno veanlo aver si le sirve por que ami no me fue XD bueno a quien le sirva que postee y me ayude sld2
|
|
#30
31-dic-2008, 15:42
|
||||
|
||||
|
Re: ~Base De Datos de Script de EMD~
-Nombre Del Script: Menu FFVII Personalizado para 1 solo personaje
-Version Del Script:no se -Rpg Maker:XP Un script de menu de FFVII personalizado por mi para que se de 1 solo jugador y algo distinto, pero por la forma nadie reconoceria que es de FFVII. El autor original es... no se quien es...pero igual le doy credito. Es MUY basico y facil de hacer, solo metí el script del menu original, y modifique todas las cajas/ventanas como se llamen. Esta hecho para UN SOLO PERSONAJE, ni 2, ni 3 ni mas. La verdad es que no se si os funcionara, porque como esta hecho por el Maker mas gafe de la historia, pues... -Caracteristicas: Lo de siempre, pegar encima de Main. No hace falta cambiar el Scene_Menu original ni nada de eso. Se puede optar por usar el Chara o la Face en el menu. (Esto no lo puse yo, ¿eh?) -AVISO Seguramente tendreis que cambiar las FUENTES del script, porque hay varias y estan divididas por algunos menus. Ahora esta la fuente "Book Antiqua" para todos los menus.
Spoiler
Código:
#*********************************************************
#Final Fantasy Personalizado (Autor original: Yo no recordar quien hacer esto)
#*********************************************************
#AVISO: Está configurado para usar faces, si quieres usar el charset
#del personaje, como en toda la vida del RPGXP, lee adelante.
#AVISO 2: Lo hice expresamente para que no aparezca el
#nombre del personaje, porque si es de un sólo
#personaje ya se debe saber cómo se llama, no?
#Si quieres usar faces:
#Crea una nueva carpeta en Characters y llámala Faces
#Para añadir faces, pon una imagen de 80 x 80 pixels en la carpeta Faces y llámala igual que el charaset.
#If text does not appear, right click and select Replace
#Si no quieres caras, ve a la línea 91
#ahí explica lo que tienes que hacer.
#========================================
#■ Window_Base
#--------------------------------------------------------------------------
# Setting functions for the "Base"
#========================================
class Window_Base < Window
def draw_actor_face(actor, x, y)
face = RPG::Cache.character("Faces/" + actor.character_name, actor.character_hue)
fw = face.width
fh = face.height
src_rect = Rect.new(0, 0, fw, fh)
self.contents.blt(x - fw / 23, y - fh, face, src_rect)
end
end
def draw_actor_battler_graphic(actor, x, y)
bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue)
cw = bitmap.width
ch = bitmap.height
src_rect = Rect.new(0, 0, cw, ch)
self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)
end
#========================================
#■ Game_Map
#--------------------------------------------------------------------------
# Setting functions for the Map
#========================================
class Game_Map
def name
$map_infos[@map_id]
end
end
#========================================
#■ Window_Title
#--------------------------------------------------------------------------
# Setting functions for the Title
#========================================
class Scene_Title
$map_infos = load_data("Data/MapInfos.rxdata")
for key in $map_infos.keys
$map_infos[key] = $map_infos[key].name
end
end
#========================================================
# ■ Window_MenuStatus
#------------------------------------------------------------------------
# Sets up the Choosing.
#========================================================
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# Set up
#--------------------------------------------------------------------------
def initialize
super(0, 0, 435, 135)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = "Book Antiqua"
self.contents.font.size = 25
refresh
self.active = false
self.index = -1
end
#--------------------------------------------------------------------------
# Drawing Info on Screen
#--------------------------------------------------------------------------
def refresh
self.contents.clear
@item_max = $game_party.actors.size
for i in 0...$game_party.actors.size
x = 94
y = i * 55
actor = $game_party.actors[i]
draw_actor_face(actor, 12, y + 90) #Para quitar las faces, pon # al comienzo de esta línea
#draw_actor_graphic(actor, 48, y + 65) #y quita el # de ésta línea.
draw_actor_class(actor, x + 80, y) #Para volver a poner faces, pon un # en la linea 92 y quítalo en la 91
draw_actor_level(actor, x, y + 18)
draw_actor_state(actor, x + 200, y)
draw_actor_exp(actor, x+ 144, y + 38)
draw_actor_hp(actor, x, y + 38)
draw_actor_sp(actor, x, y + 58)
end
end
#--------------------------------------------------------------------------
# Update of Cursor
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
else
self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
end
end
end
#=======================================#
# ■Window_GameStats #
# written by AcedentProne #
#-----------------------------------------------------------------------#
class Window_GameStats < Window_Base
def initialize
super(0, 0, 160, 80)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = "Book Antiqua"
self.contents.font.size = 20
refresh
end
def refresh
self.contents.clear
self.contents.font.color = system_color
# Draw "Time"
@total_sec = Graphics.frame_count / Graphics.frame_rate
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
text = sprintf("%02d:%02d:%02d", hour, min, sec)
self.contents.font.color = normal_color
self.contents.draw_text(4, 6, 120, 32, text, 2)
self.contents.font.color = system_color
self.contents.draw_text(4, -10, 120, 32, "Tiempo")
#Drawing Gold
self.contents.font.color = normal_color
self.contents.draw_text(4, 22, 120, 32,$game_party.gold.to_s + " " +$data_system.words.gold, 2)
self.contents.font.color = system_color
self.contents.draw_text(4, 22, 120, 32, $data_system.words.gold, 2)
end
#--------------------------------------------------------------------------
# Update of The count
#--------------------------------------------------------------------------
def update
super
if Graphics.frame_count / Graphics.frame_rate != @total_sec
refresh
end
end
end
#========================================================
# ■ Window_Mapname
#------------------------------------------------------------------------
# Draws the Map name
#========================================================
class Window_Mapname < Window_Base
#--------------------------------------------------------------------------
# Set up
#--------------------------------------------------------------------------
def initialize
super(0, 0, 320, 60)
self.contents = Bitmap.new(width - 52, height - 32)
self.contents.font.name = "Book Antiqua"
self.contents.font.size = 25
refresh
end
#--------------------------------------------------------------------------
# Draws info on screen
#--------------------------------------------------------------------------
def refresh
self.contents.clear
# Map Name
#map = $game_map.name
self.contents.font.color = system_color
self.contents.draw_text(4, 0, 220, 32, "Localización")
self.contents.font.color = normal_color
self.contents.draw_text(175, 0, 80, 32, $game_map.name)
end
end
#========================================================
# ■ Scene_Menu
#------------------------------------------------------------------------
# FF7 menu laytout as requested by AcedentProne.
#========================================================
class Scene_Menu
#--------------------------- edit-------------------------------
attr_reader :status_window
#/--------------------------- edit-------------------------------
def initialize(menu_index = 0)
@menu_index = menu_index
end
def main
s1 = $data_system.words.item
s2 = $data_system.words.skill
s3 = $data_system.words.equip
s4 = "Estado"
s5 = "Guardar"
s6 = "Salir"
#--------------------------- edit-------------------------------
# Command menu
# Size = Screen height - border sizes -
# GameStatus menu - Spacing from GameStatus
@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6,])
@command_window.x = 640 - @command_window.width
@command_window.y = 195
@command_window.z = 110
@command_window.index = @menu_index
if $game_party.actors.size == 0
@command_window.disable_item(0)
@command_window.disable_item(1)
@command_window.disable_item(2)
@command_window.disable_item(3)
end
if $game_system.save_disabled
@command_window.disable_item(4)
end
@map = Window_Mapname.new
@map.x = 640 - @map.width
@map.y = 480 - @map.height - 1
@map.z = 110
# Lower right box
@game_stats_window = Window_GameStats.new
@game_stats_window.x = 480 - @game_stats_window.width
@game_stats_window.y = 640 - @command_window.height - @game_stats_window.height + 3
@game_stats_window.z =110
# Status window
@status_window = Window_MenuStatus.new
@status_window.x = 100
@status_window.y = 3
@status_window.z = 100
Graphics.transition
loop do
Graphics.update
Input.update
update
if $scene != self
break
end
end
Graphics.freeze
@command_window.dispose
@game_stats_window.dispose
@status_window.dispose
@map.dispose
end
#--------------------------------------------------------------------
# Updating
#--------------------------------------------------------------------
def update
@command_window.update
@game_stats_window.update
@status_window.update
@map.update
if @command_window.active
update_command
return
end
if @status_window.active
update_status
return
end
end
#--------------------------------------------------------------------
# Updating the Command Selection
#--------------------------------------------------------------------
def update_command
# If B button is pused
if Input.trigger?(Input::B)
# Plays assigned SE
$game_system.se_play($data_system.cancel_se)
# Go to Map
$scene = Scene_Map.new
return
end
# If C button is pused
if Input.trigger?(Input::C)
# Checks actor size
if $game_party.actors.size == 0 and @command_window.index < 4
# plays SE
$game_system.se_play($data_system.buzzer_se)
return
end
case @command_window.index
when 0
$game_system.se_play($data_system.decision_se)
$scene = Scene_Item.new
when 1
$game_system.se_play($data_system.decision_se)
@command_window.active = false
@status_window.active = true
@status_window.index = 0
when 2
$game_system.se_play($data_system.decision_se)
@command_window.active = false
@status_window.active = true
@status_window.index = 0
when 3
$game_system.se_play($data_system.decision_se)
@command_window.active = false
@status_window.active = true
@status_window.index = 0
when 4
if $game_system.save_disabled
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
$scene = Scene_Save.new
when 5
$game_system.se_play($data_system.decision_se)
$scene = Scene_End.new
when 6
$game_system.se_play($data_system.decision_se)# Fonction qui perrmets de jouer le son d'accés au menu.
@checker = 0
@command_window.active = false
@status_window.active = true
@status_window.index = 0
end
return
end
end
#--------------------------------------------------------------------
# Updating Status Screen
#--------------------------------------------------------------------
def update_status
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@command_window.active = true
@status_window.active = false
@status_window.index = -1
return
end
if Input.trigger?(Input::C)
case @command_window.index
when 1
if $game_party.actors[@status_window.index].restriction >= 2
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
$scene = Scene_Skill.new(@status_window.index)
when 2
$game_system.se_play($data_system.decision_se)
$scene = Scene_Equip.new(@status_window.index)
when 3
$game_system.se_play($data_system.decision_se)
$scene = Scene_Status.new(@status_window.index)
when 6
$game_system.se_play($data_system.decision_se)# Fonction qui perrmets de jouer le son d'accés au menu.
if @checker == 0
@changer = $game_party.actors[@status_window.index]
@where = @status_window.index
@checker = 1
else
$game_party.actors[@where] = $game_party.actors[@status_window.index]
$game_party.actors[@status_window.index] = @changer
@checker = 0
@status_window.refresh
end
end
return
end
end
end
-Screen http://img179.imageshack.us/img179/9863/ff7menupjw2.png -credito Desconocido...
|
|
| Herramientas | |
| Desplegado | |
|
|
Temas Similares para: ~Base De Datos de Script de EMD~
|
||||
| Tema | Autor | Foro | Respuestas | Último mensaje |
| Aplicación Base de datos de .ISOS | Áldaron | Playstation | 15 | 21-jul-2008 21:05 |
| Mi firma a base de paint | Miguel_ | Exposición de diseños | 3 | 11-jul-2008 02:10 |
| Data Base Error(pag Emd) | Espartan94 | Ayuda | 11 | 03-jun-2008 23:57 |
| Gestion de Base de Datos con *FileMaker* | sawyer3000 | Descargas directas | 0 | 02-nov-2007 15:26 |
Mode Lineal
