Kinsoyo RGSS3 Factory[box2 class=titlebg title=Descrição]
Essa fábrica eu criei para que vocês possam pedir os scripts que vocês precisam, mas que sejam básicos também, pois ando precisando de ideias! De preferência irei aceitar scripts que envolvam scenes e windows, pois são minhas partes preferidas no rgss3...
[/box2]
[box2 class=titlebg title=Trabalhadores]
| Miguel8884 | | Status: Livre |
|
Exemplos:
Spoiler
Exemplo 1 (http://centrorpg.com/index.php?topic=9521.0) |
Exemplo 2 (http://centrorpg.com/index.php?topic=9526.0) |
Pedidos para:
Spoiler
RMVXACE - Scripts básicos - Scenes e windows(preferência) - Faço imagens, mas nada muito complexo
[/box2]
[box2 class=titlebg title=Regras]
- Não aceito mais de um pedido
- Pedidos muito complexos não serão aceitos
- Não desrespeite os membros da fábrica
- Seja claro em seu pedido, o mais claro possível
- Não faremos as imagens, a não ser que o membro da fábrica aceite fazer as imagens
- Verifique a quantidade de pedidos incompletos da semana na fila, não serão aceitos mais do que 5 pedidos
[/box2]
[box2 class=titlebg title=Ficha dos pedidos]
Ficha
Membro: Qual membro da fábrica você quer que faça seu pedido
Pedido: Descreva seu pedido, lembre-se, seja o mais claro possível
Imagens: Se o script tiver alguma imagem e o membro que for faze-lo não aceitar fazer as imagens, coloque-as aqui
Algo em que se basear: Se tiver algum script para que o membro se baseie, coloque-o aqui
Complexidade da configuração: A quantidade de configuração no script, se você quiser poder configurar quase que tudo no script, coloque muito, e vice-versa se quiser pouco, isso interfere no tempo de entrega
Tamanho da tela: O tamanho da tela do maker que está usando
[/box2]
[box2 class=titlebg title=Pedidos concluídos]
Nenhum ainda...
[/box2]
[box2 class=titlebg title=Pedidos em andamento]
[progress=100]Kerton Games - Completo![/progress]
[progress=100]ArrowPotter - Completo![/progress]
[progress=100]Hategum rpg - Completo![/progress]
[progress=100]ArrowPotter - Completo![/progress]
[progress=100]Nick Rock - Completo![/progress]
[progress=100]Equinho - Completo![/progress]
[progress=100]ArrowPotter - Completo![/progress]
[progress=0]KertonGames - Pedido longo![/progress]
[/box2]
[box2 class=titlebg title=Adicional]
Espero que seja útil a vocês, como será útil para mim![/box2]
Membro: Miguel884
Pedido: Preciso de um script que mude a Cena do Save deixa ela simples e com uma váriavel que mostre a porcentagem do jogo.
Imagens: Nenhuma
Complexidade da configuração: Gostaria de uma boa configuração.
Ok...
Bem, é bem fácil seu pedido até, mas a única coisa que gostaria que você especificasse é: como assim mais simples? Se puder fazer um esquema básico no paint ou algo parecido :blink:
Pedido aceito esperando mais informações
Queria um igual a este, do Star Stealing Prince:
(http://imgur.com/xmEeL5o)
Mas seriam apenas 4 slots mesmo? E quer que adicione suporte para fundo com imagens?
Sim apenas 4 slots, e não nada de fundos.
Pedido completo! Olha eu fiz assim, uma modificação básica, para 4 slots, e para inserir a porcentagem, mas se quiser, posso redimensionar e tirar a opacidade das janelas, para deixar mais parecida com a imagem que me passou! É só colocar o script, configurar do jeito que quiser e testar!
#===============================================================================
# Kinsoyo Factory - RGSS3 - Miguel8884
# Modificação no Scene_Save
#===============================================================================
module Save_Config
#--------------------------------------------------------------------------
# * Configurações
#--------------------------------------------------------------------------
# String antes da porcentagem em número ser mostrada #
Percent_Prefix = "Complete:"
# String depois da porcentagem em número ser mostrada #
Percent_Sufix = "%"
# Texto superior na hora de salvar #
Help_Text = ""
# Texto superior na hora de carregar #
HelpLoad_Text = ""
# Variável que guarda a porcentagem de completo #
Percent_Var = 1
# Largura da janela de porcentagem #
Percent_Window_Width = 200
#--------------------------------------------------------------------------
# * Fim das configurações
#--------------------------------------------------------------------------
end
# Aqui começa o script #
module DataManager
#--------------------------------------------------------------------------
# * Número máximo de arquivos salvos
#--------------------------------------------------------------------------
def self.savefile_max
return 4
end
end
class Window_PercentGame < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize(x,y,width,var,line_number = 1)
super(x,y,width,fitting_height(line_number))
draw_text(0,0,width,24,"#{Save_Config::Percent_Prefix} #{$game_variables[var]}#{Save_Config::Percent_Sufix}")
end
end
class Window_Help < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# line_number : número de linhas
# width : largura
#--------------------------------------------------------------------------
def initialize(line_number = 2,width = Graphics.width)
super(0, 0, width, fitting_height(line_number))
end
end
class Scene_File < Scene_MenuBase
alias gst_fct_sve_start start
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
gst_fct_sve_start
create_percent_window
end
#--------------------------------------------------------------------------
# * Criação da janela de ajuda.
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_Help.new(1,Graphics.width-Save_Config::Percent_Window_Width)
@help_window.set_text(help_window_text)
end
def create_percent_window
@percent_window = Window_PercentGame.new(Graphics.width-Save_Config::Percent_Window_Width,0,Save_Config::Percent_Window_Width,Save_Config::Percent_Var)
end
end
module Vocab
#--------------------------------------------------------------------------
# * Vocabulários para janela de salvar e carregar
#--------------------------------------------------------------------------
SaveMessage = Save_Config::Help_Text
LoadMessage = Save_Config::HelpLoad_Text
end
# Fim do script #
Membro: Miguel884
Pedido: Preciso de um script que analize a pasta do projeto do jogo, por exemplo se tiver o arquivo "DLC" na pasta do jogo o personagem é teletransportado para tal lugar se não estiver ele é teletransportado para outro lugar, gostaria que aceitasse arquivos do bloco de notas exemplo: DLC.txt
Imagens: Não é necessário
Complexidade da configuração: Queria que tivesse uma Switch que ativasse o sistema.
[box2 class=titlebg title=Pedido]
Membro: Miguel884
Pedido: Janela de Itens Customizável parecida com a do próprio RMVXAce, só que com apenas uma coluna de itens e do outro lado uma imagen que representará cada itens.... nada muito grande, que eu possa editar no aproprio script qual imagem será usada para o ID de tal Item ou pelo próprio Database em "Comentário". Também se possível ao invés de uma só coluna, uma grade de itens sem nome, como na imagem:
Spoiler
(http://i1359.photobucket.com/albums/q796/LipeJamesPotter/MB_Background_zpsb0e29372.png)
1- Imagem que representa o item que deve estar na pasta "Pictures" ou definida no próprio script pelo ID do Item.
2- Detalhes do item que estará na descrição do Item do Database.
3- Nome da janela que pode ser modificado de "Janela de Itens" etc.
4- Pocket é onde seus itens ficam para ser usados5- Mochila é onde ficam os itens que não serão usados pois estou usando um script de Banco.6- São itens, queria que eles ficassem em GRADE mas pode ser lista tanto faz.
Imagens: Spoiler
(http://i1359.photobucket.com/albums/q796/LipeJamesPotter/MB_Background_zpsb0e29372.png)
Pode se basear no script Window_ItemList:
Window_ItemList
#==============================================================================
# ** Window_ItemList
#------------------------------------------------------------------------------
# Esta janela exibe a lista de itens possuidos na tela de itens.
#==============================================================================
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
# height : altura
#--------------------------------------------------------------------------
def initialize(x, y, width, height)
super
@category = :none
@data = []
end
#--------------------------------------------------------------------------
# * Definição de categoria
#--------------------------------------------------------------------------
def category=(category)
return if @category == category
@category = category
refresh
self.oy = 0
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 2
end
#--------------------------------------------------------------------------
# * Aquisição do número máximo de itens
#--------------------------------------------------------------------------
def item_max
@data ? @data.size : 1
end
#--------------------------------------------------------------------------
# * Aquisição das informações do item
#--------------------------------------------------------------------------
def item
@data && index >= 0 ? @data[index] : nil
end
#--------------------------------------------------------------------------
# * Definição de habilitação de seleção
#--------------------------------------------------------------------------
def current_item_enabled?
enable?(@data[index])
end
#--------------------------------------------------------------------------
# * Inclusão do item na lista
# item : item
#--------------------------------------------------------------------------
def include?(item)
case @category
when :item
item.is_a?(RPG::Item) && !item.key_item?
when :weapon
item.is_a?(RPG::Weapon)
when :armor
item.is_a?(RPG::Armor)
when :key_item
item.is_a?(RPG::Item) && item.key_item?
else
false
end
end
#--------------------------------------------------------------------------
# * Definição de habilitação do item
# item : item
#--------------------------------------------------------------------------
def enable?(item)
$game_party.usable?(item)
end
#--------------------------------------------------------------------------
# * Criação da lista de itens
#--------------------------------------------------------------------------
def make_item_list
@data = $game_party.all_items.select {|item| include?(item) }
@data.push(nil) if include?(nil)
end
#--------------------------------------------------------------------------
# * Retorno à seleção anterior
#--------------------------------------------------------------------------
def select_last
select(@data.index($game_party.last_item.object) || 0)
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
if item
rect = item_rect(index)
rect.width -= 4
draw_item_name(item, rect.x, rect.y, enable?(item))
draw_item_number(rect, item)
end
end
#--------------------------------------------------------------------------
# * Desenho do número de itens possuido
# rect : retângulo
# item : item
#--------------------------------------------------------------------------
def draw_item_number(rect, item)
draw_text(rect, sprintf(":%2d", $game_party.item_number(item)), 2)
end
#--------------------------------------------------------------------------
# * Atualização da janela de ajuda
#--------------------------------------------------------------------------
def update_help
@help_window.set_item(item)
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
make_item_list
create_contents
draw_all_items
end
end
Quero pode configurar algumas coisas.
[/box2]
Bem, é isso, tentei ser o mais explicativo possível, não precisa fazer tudo (se for fazer) apenas o que puder (desde que possa mostrar a imagem do item) :ok: Obrigado!
Citação de: KertonGames online 03/09/2014 às 19:52
Membro: Miguel884
Pedido: Preciso de um script que analize a pasta do projeto do jogo, por exemplo se tiver o arquivo "DLC" na pasta do jogo o personagem é teletransportado para tal lugar se não estiver ele é teletransportado para outro lugar, gostaria que aceitasse arquivos do bloco de notas exemplo: DLC.txt
Imagens: Não é necessário
Complexidade da configuração: Queria que tivesse uma Switch que ativasse o sistema.
Olha cara, é um pouco complexo para mim... Eu vou ver se consigo fazer depois de algumas análises. Se eu conseguir eu te aviso por mp.
Citação de: ArrowPotter online 03/09/2014 às 22:02
[box2 class=titlebg title=Pedido]Membro: Miguel884
Pedido: Janela de Itens Customizável parecida com a do próprio RMVXAce, só que com apenas uma coluna de itens e do outro lado uma imagen que representará cada itens.... nada muito grande, que eu possa editar no aproprio script qual imagem será usada para o ID de tal Item ou pelo próprio Database em "Comentário". Também se possível ao invés de uma só coluna, uma grade de itens sem nome, como na imagem:
Spoiler
(http://i1359.photobucket.com/albums/q796/LipeJamesPotter/MB_Background_zpsb0e29372.png)
2- Detalhes do item que estará na descrição do Item do Database.
3- Nome da janela que pode ser modificado de "Janela de Itens" etc.
4- Pocket é onde seus itens ficam para ser usados
5- Mochila é onde ficam os itens que não serão usados pois estou usando um script de Banco.
6- São itens, queria que eles ficassem em GRADE mas pode ser lista tanto faz.
Imagens: Spoiler
(http://i1359.photobucket.com/albums/q796/LipeJamesPotter/MB_Background_zpsb0e29372.png)
Window_ItemList
#==============================================================================
# ** Window_ItemList
#------------------------------------------------------------------------------
# Esta janela exibe a lista de itens possuidos na tela de itens.
#==============================================================================
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
# height : altura
#--------------------------------------------------------------------------
def initialize(x, y, width, height)
super
@category = :none
@data = []
end
#--------------------------------------------------------------------------
# * Definição de categoria
#--------------------------------------------------------------------------
def category=(category)
return if @category == category
@category = category
refresh
self.oy = 0
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 2
end
#--------------------------------------------------------------------------
# * Aquisição do número máximo de itens
#--------------------------------------------------------------------------
def item_max
@data ? @data.size : 1
end
#--------------------------------------------------------------------------
# * Aquisição das informações do item
#--------------------------------------------------------------------------
def item
@data && index >= 0 ? @data[index] : nil
end
#--------------------------------------------------------------------------
# * Definição de habilitação de seleção
#--------------------------------------------------------------------------
def current_item_enabled?
enable?(@data[index])
end
#--------------------------------------------------------------------------
# * Inclusão do item na lista
# item : item
#--------------------------------------------------------------------------
def include?(item)
case @category
when :item
item.is_a?(RPG::Item) && !item.key_item?
when :weapon
item.is_a?(RPG::Weapon)
when :armor
item.is_a?(RPG::Armor)
when :key_item
item.is_a?(RPG::Item) && item.key_item?
else
false
end
end
#--------------------------------------------------------------------------
# * Definição de habilitação do item
# item : item
#--------------------------------------------------------------------------
def enable?(item)
$game_party.usable?(item)
end
#--------------------------------------------------------------------------
# * Criação da lista de itens
#--------------------------------------------------------------------------
def make_item_list
@data = $game_party.all_items.select {|item| include?(item) }
@data.push(nil) if include?(nil)
end
#--------------------------------------------------------------------------
# * Retorno à seleção anterior
#--------------------------------------------------------------------------
def select_last
select(@data.index($game_party.last_item.object) || 0)
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
if item
rect = item_rect(index)
rect.width -= 4
draw_item_name(item, rect.x, rect.y, enable?(item))
draw_item_number(rect, item)
end
end
#--------------------------------------------------------------------------
# * Desenho do número de itens possuido
# rect : retângulo
# item : item
#--------------------------------------------------------------------------
def draw_item_number(rect, item)
draw_text(rect, sprintf(":%2d", $game_party.item_number(item)), 2)
end
#--------------------------------------------------------------------------
# * Atualização da janela de ajuda
#--------------------------------------------------------------------------
def update_help
@help_window.set_item(item)
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
make_item_list
create_contents
draw_all_items
end
end
[/box2]
Bem, é isso, tentei ser o mais explicativo possível, não precisa fazer tudo (se for fazer) apenas o que puder (desde que possa mostrar a imagem do item) :ok: Obrigado!
Bem, eu acho que consigo fazer! Pedido aceito!
Oba! Você é o primeiro que aceitou (afinal foi o segundo a quem eu pedi rsrsrs) obrigado!
Citação de: KertonGames online 03/09/2014 às 19:52
Membro: Miguel884
Pedido: Preciso de um script que analize a pasta do projeto do jogo, por exemplo se tiver o arquivo "DLC" na pasta do jogo o personagem é teletransportado para tal lugar se não estiver ele é teletransportado para outro lugar, gostaria que aceitasse arquivos do bloco de notas exemplo: DLC.txt
Imagens: Não é necessário
Complexidade da configuração: Queria que tivesse uma Switch que ativasse o sistema.
Acho que tem um comando no próprio Chamar Script do Ace que faz isso... em sistemas de Menu por Eventos um Comando Verifica se existe o arquivo Save1.rgss3 (acho que é isso) para chamar o Carregar/Salvar. Ai é só trocar o Save1.rgss3 pelo arquivo e talz na consição. Vou ver se acho aqui e dou edit. :ok:
Eu posso fazer com algumas mudanças? Porque se for fazer igualzinho a o que você pediu, pode dar um trabalho...
Hum? Falou comigo? Ah é que eu estava distraido rsrsrs. Então, pode fazer mudanças sim, o que mais importa é a visualização do item ok?! Valeu!
ArrowPotter seu script está pronto, eu fiz algumas mudanças para facilitar e que eu achei que ficaria bom, então se quiser que mude alguma coisa só falar!
Para colocar a imagem de cada item, vá na aba de itens ou de armas ou de armaduras, e nas notas coloque:
Image=id
No lugar de id você coloca o número da imagem que você configura no próprio script, exemplo
No script eu tenho:
Photos[1] = "Life"
Então no banco de dados eu vou colocar
Image=1
O primeiro id que é 0 no script será utilizado com imagem para todos em que a imagem não for definida no banco de dados.
#===============================================================================
# ** Kynsoyo RGSS3 - Pedido
# Mudança na Scene_Item - Miguel8884
#===============================================================================
module Item_Menu_Conf
#--------------------------------------------------------------------------
# * Criação de variável - Não mexa
#--------------------------------------------------------------------------
Photo = Array.new
#--------------------------------------------------------------------------
# * Imagens
#--------------------------------------------------------------------------
# Posições das imagens #
Images_XY = [310,135]
#--------------------------------------------------------------------------
# * Vocabulário
#--------------------------------------------------------------------------
# Vocabulário para quantidade de itens #
Item_Amount_Vocab = "Possui:"
#--------------------------------------------------------------------------
# * Imagens que irão ser utilizadas para os itens
#--------------------------------------------------------------------------
Photo[0] = ""
Photo[1] = "Img1"
#--------------------------------------------------------------------------
# * Fim das configurações
#--------------------------------------------------------------------------
end
# Aqui começa o script #
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição de largura do item
#--------------------------------------------------------------------------
def item_width
return 24
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
return 24
end
#--------------------------------------------------------------------------
# * Aquisição do espaçamento entre os itens
#--------------------------------------------------------------------------
def spacing
return 15
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 7
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
if item
rect = item_rect(index)
rect.width -= 4
draw_icon(item.icon_index, rect.x, rect.y, enable?(item))
end
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Aliases
#--------------------------------------------------------------------------
alias gst_sef_start start
alias gst_sef_update update
alias gst_sef_terminate terminate
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
gst_sef_start
create_item_datawindow
end
#--------------------------------------------------------------------------
# * Atualização do processo
#--------------------------------------------------------------------------
def update
gst_sef_update
@data_window.actual_item = @item_window.item
end
#--------------------------------------------------------------------------
# * Finalização do processo
#--------------------------------------------------------------------------
def terminate
gst_sef_terminate
@data_window.dispose_images
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wy = @category_window.y + @category_window.height
wh = Graphics.height - wy
@item_window = Window_ItemList.new(0, wy, Graphics.width-252, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela dos dados dos itens
#--------------------------------------------------------------------------
def create_item_datawindow
wy = @category_window.y + @category_window.height
wh = Graphics.height - wy
@data_window = Window_ItemData.new(@item_window.width,wy,Graphics.width-@item_window.width,wh,@viewport)
@data_window.viewport = @viewport
end
end
class Window_ItemData < Window_Base
attr_accessor :actual_item
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
# height : altura
# viewport : camada
#--------------------------------------------------------------------------
def initialize(x,y,width,height,viewport)
super(x,y,width,height)
@actual_item = 0
@image = Sprite.new(viewport)
refresh
end
#--------------------------------------------------------------------------
# * Atualização do objeto
#--------------------------------------------------------------------------
def update
super
refresh
end
#--------------------------------------------------------------------------
# * Criação e renovação do conteúdo
#--------------------------------------------------------------------------
def refresh
self.contents.clear
if @actual_item != 0 and @actual_item != nil
draw_text(0,210,self.width,24,@actual_item.name)
draw_text(0,234,self.width,24,"#{Item_Menu_Conf::Item_Amount_Vocab} #{sprintf("%2d",$game_party.item_number(@actual_item))}")
if @actual_item.note.match(/Image=(\d+)/im)
image_note = Item_Menu_Conf::Photo[$1.to_i]
else
image_note = Item_Menu_Conf::Photo[0]
end
@image.bitmap = Cache.picture(image_note)
@image.x = Item_Menu_Conf::Images_XY[0]
@image.z = 100
@image.y = Item_Menu_Conf::Images_XY[1]
end
end
#--------------------------------------------------------------------------
# * Apagar as imagens
#--------------------------------------------------------------------------
def dispose_images
@image.bitmap.dispose
@image.dispose
end
end
# Fim do script #
Membro: miguel8884
Pedido: Menu edit
Imagens:
Spoiler
(http://i.imgur.com/rX7CExL.png)
Spoiler
(http://i.imgur.com/Y6U7rze.png)
Spoiler
(http://i.imgur.com/AkcpQ5t.png)
Spoiler
(http://i.imgur.com/GLXqCwG.png)
Algo em que se basear: Eu pensei que poderia usar aquele script de enciclopedia so que não encontrei : (
Complexidade da configuração: Bem ...não sei se é complexo...
Sobre o windons Batler era tipo assim
Spoiler
(http://i.imgur.com/hN17hcL.png)
Aí vai depender da edição! Se você me passar a imagem, use a ficha aí se for possível eu faço!
Oba! Vou testar depois dou edit! Obrigado!
-> Edit!
Funcionou perfeitamente, estou usando um script para aumentar a tela ai fica com 640x480 (acho que é isso) então a imagem está sobrepondo o texto "Possui" e talz, tem como descer esse texto? Ai está uma imagem de como a a imagem fica. O script ficou ótimo só precisa descer o texto um pouco! Valeu mesmo!
Spoiler
(http://i1359.photobucket.com/albums/q796/LipeJamesPotter/HandsCardsNUMBER_zps382a4c92.png)
Olha ficaria meio difícil para mim reposicionar perfeitamente, mas eu adicionei no script uma configuração para vc colocar a posição vertical.
Aumente para baixar mais e diminua para subir!
#===============================================================================
# ** Kynsoyo RGSS3 - Pedido
# Mudança na Scene_Item - Miguel8884
#===============================================================================
module Item_Menu_Conf
#--------------------------------------------------------------------------
# * Criação de variável - Não mexa
#--------------------------------------------------------------------------
Photo = Array.new
#--------------------------------------------------------------------------
# * Imagens
#--------------------------------------------------------------------------
# Posições das imagens #
Images_XY = [310,135]
Name_And_Amount_Y = [254,274]
#--------------------------------------------------------------------------
# * Vocabulário
#--------------------------------------------------------------------------
# Vocabulário para quantidade de itens #
Item_Amount_Vocab = "Possui:"
#--------------------------------------------------------------------------
# * Imagens que irão ser utilizadas para os itens
#--------------------------------------------------------------------------
Photo[0] = ""
Photo[1] = "Img1"
#--------------------------------------------------------------------------
# * Fim das configurações
#--------------------------------------------------------------------------
end
# Aqui começa o script #
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição de largura do item
#--------------------------------------------------------------------------
def item_width
return 24
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
return 24
end
#--------------------------------------------------------------------------
# * Aquisição do espaçamento entre os itens
#--------------------------------------------------------------------------
def spacing
return 15
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 7
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
if item
rect = item_rect(index)
rect.width -= 4
draw_icon(item.icon_index, rect.x, rect.y, enable?(item))
end
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Aliases
#--------------------------------------------------------------------------
alias gst_sef_start start
alias gst_sef_update update
alias gst_sef_terminate terminate
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
gst_sef_start
create_item_datawindow
end
#--------------------------------------------------------------------------
# * Atualização do processo
#--------------------------------------------------------------------------
def update
gst_sef_update
@data_window.actual_item = @item_window.item
end
#--------------------------------------------------------------------------
# * Finalização do processo
#--------------------------------------------------------------------------
def terminate
gst_sef_terminate
@data_window.dispose_images
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wy = @category_window.y + @category_window.height
wh = Graphics.height - wy
@item_window = Window_ItemList.new(0, wy, Graphics.width-252, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela dos dados dos itens
#--------------------------------------------------------------------------
def create_item_datawindow
wy = @category_window.y + @category_window.height
wh = Graphics.height - wy
@data_window = Window_ItemData.new(@item_window.width,wy,Graphics.width-@item_window.width,wh,@viewport)
@data_window.viewport = @viewport
end
end
class Window_ItemData < Window_Base
attr_accessor :actual_item
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
# height : altura
# viewport : camada
#--------------------------------------------------------------------------
def initialize(x,y,width,height,viewport)
super(x,y,width,height)
@actual_item = 0
@image = Sprite.new(viewport)
refresh
end
#--------------------------------------------------------------------------
# * Atualização do objeto
#--------------------------------------------------------------------------
def update
super
refresh
end
#--------------------------------------------------------------------------
# * Criação e renovação do conteúdo
#--------------------------------------------------------------------------
def refresh
self.contents.clear
if @actual_item != 0 and @actual_item != nil
draw_text(0,Item_Menu_Conf::Name_And_Amount_Y[0],self.width,24,@actual_item.name)
draw_text(0,Item_Menu_Conf::Name_And_Amount_Y[1],self.width,24,"#{Item_Menu_Conf::Item_Amount_Vocab} #{sprintf("%2d",$game_party.item_number(@actual_item))}")
if @actual_item.note.match(/Image=(\d+)/im)
image_note = Item_Menu_Conf::Photo[$1.to_i]
else
image_note = Item_Menu_Conf::Photo[0]
end
@image.bitmap = Cache.picture(image_note)
@image.x = Item_Menu_Conf::Images_XY[0]
@image.z = 100
@image.y = Item_Menu_Conf::Images_XY[1]
end
end
#--------------------------------------------------------------------------
# * Apagar as imagens
#--------------------------------------------------------------------------
def dispose_images
@image.bitmap.dispose
@image.dispose
end
end
# Fim do script #
Valeu funcionou!!! Obrigado! Como estou sem scripter na minha equipe, tive que lhe pedir! Obrigado!!!
Nada, se precisar de mais alguma coisa, só pedir! A fábrica está aqui para isso!
Então, eu editei la em cima o pedido, você consegue fazer?
Bem é um pedido bem grande, o menu eu entendi, tenho quase certeza que consigo fazer, já a da batalha ficou meio confuso /=, se puder explicar um pouco melhor...
[box2 class=titlebg title=Pedido]
Membro: Miguel8884
Pedido: Queria poder adicionar "Gêneros" aos itens, ai no próprio mapa eu criaria um Evento Comum com Chamar Script, so que nesse Chamar Script eu poderia colocar um dos gêneros, então apareceria a Window de Itens só que ocultando os itens que não são do gênero definido. Ai o jogador só poderá escolher os itens de tal gênero (isso não quer dier que os outros itens tenham sido deletados da mochila).
Imagens: Não necessário.
Algo em que se basear: Encontrei esse script de restaurante que acho que pode ser utilizado como base... ele é de um membro da MRM, você conhece? Sem sombra de dúvida você conhece ele. :clown:
Spoiler
#===============================================================================
# ** Restaurant Menu System
# Autor: miguel8884
#-------------------------------------------------------------------------------
# Data de lançamento: 21/08/2014
# Versão: 1.0
#-------------------------------------------------------------------------------
# Dependências:
# * Nenhum
# Sugestões:
# * Geconomy
#-------------------------------------------------------------------------------
# Descrição:
#
# O script permite você criar uma tela onde aparece um cardápio que mostra os
# itens que você pode comprar, sendo que pelas opções o item pode ir para o
# seu inventário ou simplesmente ser consumido na hora.
#-------------------------------------------------------------------------------
# Características:
# * Suporta multiplas economias!
# * Itens ilimitados e diferentes menus!
# * Possibilidade de por imagens ilimitadas!
# * Fácil configuração!
# * Grande quantidade de opções!
# * Altamente configurável!
# * Possível mudanças no jogador, em variáveis, e switches!
#-------------------------------------------------------------------------------
# Log:
# v1.0
# 21/08/2014 - Script lançado!
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# - Modificando o menu atual -
#
# Nunca inicie o cena antes de definir o menu para evitar bugs.
# Apenas use no chamar script:
# change_menu(id)
# No lugar de id coloque o menu que vai aparecer quando a cena for chamada.
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# - Chamando a cena -
# Para chamar a cena, use no chamar script:
#
# SceneManager.call(Scene_Rest)
#===============================================================================
module Rest
#--------------------------------------------------------------------------
# * Criação das variáveis - Não mexa
#--------------------------------------------------------------------------
# Criação da hash que os itens vão ser criados #
Items = Hash.new
# Criação da array que os menus vão ser criados #
Menus = Array.new
#--------------------------------------------------------------------------
# * Configurações
#--------------------------------------------------------------------------
# Ganhar o item que você comprar no restaurante? #
Gain_Item = true
# Consumir automaticamente o item que você comprar no restaurante? #
Consume_Item = true
# Possibilidade de ativar as switches ao consumir algum item? #
Use_Switches = false
# Possibilidade de usar variáveis ao consumir algum item? #
Use_Variables = true
# Possibilidade mudar hp, mp ou status do herói? #
Change_Actor_Stats = true
# Tocar um SE ao entrar na cena? #
Play_Se_On_Enter = true
# Usar a base da window no menu? #
Use_Window_Image = false
# Possibilidade de usar o script de economias? #
Use_Geconomie = true
# Som tocado ao slecionar uma opção que não for possível #
Wrong_SE = "Buzzer1"
# Som tocado ao entrar na cena caso esteja habilitado #
Enter_SE = "Bell3"
#--------------------------------------------------------------------------
# * Vocabulário
#--------------------------------------------------------------------------
# Vocabulário da janela superior #
Top_Window_Vocab = "Cardápio"
# Vocabulário para janela de comando => comer #
Eat_Vocab = "Comidas"
# Vocabulário para janela de comando => sair #
Exit_Vocab = "Sair"
#--------------------------------------------------------------------------
# * Imagens
#--------------------------------------------------------------------------
# Alguma imagem de fundo? Se não quiser coloque como "nil" sem aspas #
Background = nil
# Animação da imagem de fundo? #
Animated_Background = false
# Velocidade da animação da imagem do fundo #
Animation_Speed = 1
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Qualquer imagem extra
# Para adicionar novas imagens:
# Abra colchetes e coloque uma vírgula [],
# Dentro você colocará:
# O nome da imagem na pasta pictures
# A posição x da imagem
# A posição y da imagem
# A opacidade da imagem - máx 255
# Tudo seguido por vírgula, exemplo:
#
# Images = [
# ["Miguel8884",10,50,255],
# ["Ghost",30,20,255]
# ]
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Image = [
["Back1",(544-314)/2,0,255]
]
#--------------------------------------------------------------------------
# * Itens
#--------------------------------------------------------------------------
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Criando um novo item
#
# Pegue o template no tópico e cole abaixo do último criado.
#
# Items[id] = {
# No lugar de id, coloque o id do item que está fazendo.
#
# name: "",
# Coloque o nome do item, não tire a vírgula, exemplo: name: "Frango",
#
# icon: id,
# No lugar de id, coloque o id do icone.
#
# price: value,
# Coloque no lugar de value o preço do item.
#
# var_id: id,
# Id da variável que você pode mudar.
#
# var: amount,
# Quantidade que você quer adicionar nessa variável, para retirar coloque o -
# na frente.
#
# switch_id: id,
# Coloque o id da switch que será ativada, se não quiser deixe como "nil" sem
# aspas.
#
# hp: amount,
# Quantidade de hp que o herói vai ter alterado.
#
# mp: amount,
# Quantidade de mp que o herói vai ter alterado.
#
# state: id,
# Id do status que o herói vai pegar, caso não queira, deixe no 0.
#
# item: id
# Id do item que o herói vai ganhar.
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Items[0] = {
name: "Porco",
icon: 200,
price: 10,
var_id: 1,
var: 15,
switch_id: 1,
hp: 10,
mp: 15,
state: 0,
item: 3
}
Items[1] = {
name: "Filé",
icon: 201,
price: 20,
var_id: 1,
var: 0,
switch_id: 1,
hp: 10,
mp: 15,
state: 1,
item: 2
}
Items[2] = {
name: "Macarrão",
icon: 202,
price: 50,
var_id: 1,
var: 0,
switch_id: 1,
hp: 10,
mp: 15,
state: 1,
item: 1
}
#--------------------------------------------------------------------------
# * Menus
#--------------------------------------------------------------------------
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Criando novos menus
#
# Menu[id] = [
# Id do menu que está criando.
#
# Economie = id,
# Economia que vai usar caso esteja usando o Geconomy, caso não queira,
# deixe como "nil" sem aspas.
#
# Item = [],
# Itens presentes no menu, coloque o id do item dentro dos colchetes
# seguido por vírgula seguid do outro item.
#
# images = []
# Coloque o id das imagens presentes nessse menu, mesmo esquema dos itens.
#- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Menus[0] = [
Economie = 0,
Item = [0,1,2],
Images = [0]
]
Menus[1] = [
Economie = 1,
Item = [0,1],
Images = []
]
#--------------------------------------------------------------------------
# * Fim das configurações
#--------------------------------------------------------------------------
end
#----------------------------------------------------------------------------
# * Classe incrementada com método de mudar o menu
#----------------------------------------------------------------------------
class Game_Interpreter
#--------------------------------------------------------------------------
# * Mudar o menu
# menu : Novo menu
#--------------------------------------------------------------------------
def change_menu(menu)
$gst_menu = menu
end
end
#----------------------------------------------------------------------------
# * Classe que cria a janela superior
#----------------------------------------------------------------------------
class Window_RestTop < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super((544-314)/2,0,314,fitting_height(1))
if Rest::Use_Window_Image == false
self.opacity = 0
end
set_text
end
#--------------------------------------------------------------------------
# * Desenha o texto
#--------------------------------------------------------------------------
def set_text
draw_text(-10,0,314,24,Rest::Top_Window_Vocab,1)
end
end
#----------------------------------------------------------------------------
# * Classe que a janela de comando horizontal
#----------------------------------------------------------------------------
class Window_RestCommand < Window_HorzCommand
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super((544-314)/2,fitting_height(1))
if Rest::Use_Window_Image == false
self.opacity = 0
end
end
#--------------------------------------------------------------------------
# * Número de colunas
#--------------------------------------------------------------------------
def col_max
return 2
end
#--------------------------------------------------------------------------
# * Largura da janela
#--------------------------------------------------------------------------
def window_width
return 314
end
#--------------------------------------------------------------------------
# * Constrói a janela de comando
#--------------------------------------------------------------------------
def make_command_list
add_command(Rest::Eat_Vocab,:eat)
add_command(Rest::Exit_Vocab,:exit)
end
end
#----------------------------------------------------------------------------
# * Janela que cria seu dinheiro
#----------------------------------------------------------------------------
class Window_Economie < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# menu : Menu atual
#--------------------------------------------------------------------------
def initialize(menu)
super((544-314)/2,416-fitting_height(1),314,fitting_height(1))
if Rest::Use_Window_Image == false
self.opacity = 0
end
@menu = menu
refresh
end
#--------------------------------------------------------------------------
# * Atualiza a janela
#--------------------------------------------------------------------------
def update
super
refresh
end
#--------------------------------------------------------------------------
# * Renova o conteúdo da janela
#--------------------------------------------------------------------------
def refresh
self.contents.clear
if Rest::Menus[@menu][0] != nil
draw_text(0,0,314,24,"#{Geconomy::Economies[Rest::Menus[@menu][0]][0]}: #{$game_party.economies[Rest::Menus[@menu][0]][1]}")
else
draw_text(0,0,314,24,"#{Vocab.currency_unit}: #{$game_party.gold}")
end
end
end
#----------------------------------------------------------------------------
# * Janela das comidas disponíveis
#----------------------------------------------------------------------------
class Window_RestEatList < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# menu : Menu a ser utilizado
#--------------------------------------------------------------------------
def initialize(menu)
@menu = menu
super((544-314)/2, 96, window_width, window_height)
if Rest::Use_Window_Image == false
self.opacity = 0
end
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 314
end
#--------------------------------------------------------------------------
# * Aquisição da altura da janela
#--------------------------------------------------------------------------
def window_height
return 416-96-fitting_height(1)
end
#--------------------------------------------------------------------------
# * Aquisição do número máximo de itens
#--------------------------------------------------------------------------
def item_max
return Rest::Menus[@menu][1].size
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
return 24
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
draw_icon(Rest::Items[Rest::Menus[@menu][1][index]][:icon],0,index*24)
draw_text(35,index*24,314,24,Rest::Items[Rest::Menus[@menu][1][index]][:name])
if Rest::Menus[@menu][0] != nil
draw_text(185,index*24,314-140,24,"#{Geconomy::Economies[Rest::Menus[@menu][0]][0]}: #{Rest::Items[Rest::Menus[@menu][1][index]][:price]}")
else
draw_text(185,index*24,314-140,24,"#{Vocab.currency_unit}: #{Rest::Items[Rest::Menus[@menu][1][index]][:price]}")
end
end
#--------------------------------------------------------------------------
# * Retorno à seleção anterior
#--------------------------------------------------------------------------
def select_last
select(self.index)
end
end
#----------------------------------------------------------------------------
# * Classe que gerencia a cena
#----------------------------------------------------------------------------
class Scene_Rest < Scene_Base
#--------------------------------------------------------------------------
# * Inicialização da cena
#--------------------------------------------------------------------------
def start
super
@images = []
play_se
create_background
create_windows
create_horz_window
create_command_window
create_images
end
#--------------------------------------------------------------------------
# * Atualização da cena
#--------------------------------------------------------------------------
def update
super
update_background
end
#--------------------------------------------------------------------------
# * Término da cena
#--------------------------------------------------------------------------
def terminate
super
dispose_background
dispose_windows
dispose_images
end
#--------------------------------------------------------------------------
# * Tocar um SE
#--------------------------------------------------------------------------
def play_se
RPG::SE.new(Rest::Enter_SE,80).play
end
#--------------------------------------------------------------------------
# * Criar as janelas
#--------------------------------------------------------------------------
def create_windows
@top_window = Window_RestTop.new
@economie_window = Window_Economie.new($gst_menu)
end
#--------------------------------------------------------------------------
# * Criar a janela de comando horizontal
#--------------------------------------------------------------------------
def create_horz_window
@horzcommand_window = Window_RestCommand.new
@horzcommand_window.set_handler(:eat,method(:eat_list))
@horzcommand_window.set_handler(:exit,method(:exit_command))
end
#--------------------------------------------------------------------------
# * Output ao confirmar a lista de comida
#--------------------------------------------------------------------------
def eat_list
@command_window.select(0)
@command_window.activate
end
#--------------------------------------------------------------------------
# * Output ao confirmar a saída da cena
#--------------------------------------------------------------------------
def exit_command
return_scene
end
#--------------------------------------------------------------------------
# * Cria a janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_RestEatList.new($gst_menu)
@command_window.set_handler(:ok,method(:on_item_ok))
@command_window.set_handler(:cancel,method(:on_cancel))
end
#--------------------------------------------------------------------------
# * Output ao confirmar um item
#--------------------------------------------------------------------------
def on_item_ok
if Rest::Menus[$gst_menu][0] == nil
if $game_party.gold > Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:price]
$game_party.lose_gold(Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:price])
if Rest::Consume_Item
if Rest::Change_Actor_Stats
$game_party.members[0].hp += Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:hp]
$game_party.members[0].mp += Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:mp]
$game_party.members[0].add_state(Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:state])
end
if Rest::Use_Variables
$game_variables[Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:var_id]] += Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:var]
end
if Rest::Use_Switches
if Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:switch_id] != nil
$game_switches[Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]]][:switch_id] = true
end
end
end
if Rest::Gain_Item
$game_party.gain_item(Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:item],1)
end
@command_window.select_last
@command_window.activate
else
RPG::SE.new(Rest::Wrong_SE,80).play
@command_window.select_last
@command_window.activate
end
elsif Rest::Menus[$gst_menu][0] != nil
if $game_party.economies[Rest::Menus[$gst_menu][0]][1] > Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:price]
$game_party.economies[Rest::Menus[$gst_menu][0]][1] -= Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:price]
if Rest::Consume_Item
if Rest::Change_Actor_Stats
$game_party.members[0].hp += Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:hp]
$game_party.members[0].mp += Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:mp]
$game_party.members[0].add_state(Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:state])
end
if Rest::Use_Variables
$game_variables[Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:var_id]] += Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:var]
end
if Rest::Use_Switches
if Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:switch_id] != nil
$game_switches[Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]]][:switch_id] = true
end
end
end
if Rest::Gain_Item
$game_party.gain_item($data_items[Rest::Items[Rest::Menus[$gst_menu][1][@command_window.index]][:item]],1)
end
@command_window.select_last
@command_window.activate
else
RPG::SE.new(Rest::Wrong_SE,80).play
@command_window.select_last
@command_window.activate
end
end
end
#--------------------------------------------------------------------------
# * Output a cancelar um item
#--------------------------------------------------------------------------
def on_cancel
@horzcommand_window.select(0)
@horzcommand_window.activate
@command_window.unselect
end
#--------------------------------------------------------------------------
# * Criar o fundo
#--------------------------------------------------------------------------
def create_background
if Rest::Background == nil
@background_sprite = Sprite.new
@background_sprite.bitmap = SceneManager.background_bitmap
@background_sprite.color.set(16, 16, 16, 128)
else
if Rest::Animated_Background
@background_sprite = Plane.new
@background_sprite.bitmap = Cache.parallax(Rest::Background)
else
@background_sprite = Sprite.new
@background_sprite.bitmap = Cache.picture(Rest::Background)
end
end
end
#--------------------------------------------------------------------------
# * Atualizar o fundo
#--------------------------------------------------------------------------
def update_background
@background_sprite.ox += 1 if @background_sprite.is_a?(Plane)
end
#--------------------------------------------------------------------------
# * Apagar o fundo
#--------------------------------------------------------------------------
def dispose_background
@background_sprite.bitmap.dispose
@background_sprite.dispose
end
#--------------------------------------------------------------------------
# * Criar as imagens extras
#--------------------------------------------------------------------------
def create_images
for i in 0..Rest::Menus[$gst_menu][2].size-1
@images.push(Sprite.new)
@images[i].bitmap = Cache.picture(Rest::Image[Rest::Menus[$gst_menu][2][0]][0])
@images[i].x = Rest::Image[Rest::Menus[$gst_menu][2][i]][1]
@images[i].y = Rest::Image[Rest::Menus[$gst_menu][2][i]][2]
@images[i].opacity = Rest::Image[Rest::Menus[$gst_menu][2][i]][3]
end
end
#--------------------------------------------------------------------------
# * Apagar as imagens extras
#--------------------------------------------------------------------------
def dispose_images
@images.each{|i|
i.bitmap.dispose
i.dispose
}
end
#--------------------------------------------------------------------------
# * Apagar as janelas
#--------------------------------------------------------------------------
def dispose_windows
@command_window.dispose
@horzcommand_window.dispose
@top_window.dispose
@economie_window.dispose
end
end
#----------------------------------------------------------------------------
# * Fim do script
#
# GST Scripts - acesse o blog:
# http://gstrgss.weebly.com/
#
# Créditos: Miguel8884 - Autor do script
#----------------------------------------------------------------------------
Deve ser Média/Difícil. [/box2]
Bem, não é para ser igual o do restaurante claro, mas deve aparecer a visualização do card definido no item... é possível sem ter que modificar o outroo script que pedi? Se não eu posso fazer umas mudanças no meu pedido. :ok:
Eu acho que conheço ele sim, lembro quando ele fez esse script! Deixa-me ver se entendi, você quer que no mapa, você defina os itens que serão mostrados na janela de itens no momento? Tipo, eu tenho 3 tipos, maça, adaga e espada, aí você quer que em um mapa apreça apenas adagas na janela de itens, aí eu possa mudar isso?
É mais ou menos isso, tomando seu exemplo, eu teria que definir um gênero para os itens, tipo:
Maçã > Fruta
Banana > Fruta
Adaga > Arma
Vestido > Roupa
Espada > Arma
Chapéu > Roupa
Uvas > Fruta
Ai no mapa eu usaria (exemplo):
Chamar Script: Scene_Gênero: Fruta
Ai apareceria na janela apenas os itens: Maçã, Banana, Uvas.
Seria uma espécie de "Itens, Armas, Armaduras" (aquelas do database) só que seriam todos apenas itens e cada item com um gênero. Só que só apareceria FRUTAS ao chamar o script com o tal gênero, no Menu pode aparecer todos os itens normalmente.
Por enquanto so os scripts do menu por favor,
o de batalha é para um outro projeto então é melhor não se preocupar com ele : )
Citação de: ArrowPotter online 05/09/2014 às 21:20
É mais ou menos isso, tomando seu exemplo, eu teria que definir um gênero para os itens, tipo:
Maçã > Fruta
Banana > Fruta
Adaga > Arma
Vestido > Roupa
Espada > Arma
Chapéu > Roupa
Uvas > Fruta
Ai no mapa eu usaria (exemplo):
Chamar Script: Scene_Gênero: Fruta
Ai apareceria na janela apenas os itens: Maçã, Banana, Uvas.
Seria uma espécie de "Itens, Armas, Armaduras" (aquelas do database) só que seriam todos apenas itens e cada item com um gênero. Só que só apareceria FRUTAS ao chamar o script com o tal gênero, no Menu pode aparecer todos os itens normalmente.
Agora eu entendi! Vou fazer sim, só vou fazer primeiro o hategum rpg, depois o seu!
Edit
Hateum rpg, seu pedido foi aceito, mas eu queria saber se o suporte vai para apenas um membro da equipe?
CitarHategum rpg, seu pedido foi aceito, mas eu queria saber se o suporte vai para apenas um membro da equipe?
Suporte? não sei, se fala da quantidade de personagens é normal, a janela pode subistituir a atual mostrando o outro personagem do jogador.
Hategum, veja se é dessa forma que você quer:
class Window_MenuStatus < Window_Selectable
def initialize(x)
super(x, window_y, window_width, window_height)
@pending_index = -1
refresh
end
def window_height
98 + 24
end
def window_y
Graphics.height-(98+24)
end
def item_height
98
end
end
class Window_MenuCommand < Window_Command
def initialize(x)
super(x, window_y)
select_last
end
def window_y
Graphics.height-(98+24)-fitting_height(7)
end
end
class Scene_Menu < Scene_MenuBase
def start
super
create_command_window
create_status_window
create_gold_window
end
def create_status_window
@status_window = Window_MenuStatus.new(0)
end
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
def create_gold_window
@gold_window = Window_Gold.new
@gold_window.x = 160
@gold_window.y = Graphics.height - @gold_window.height - @status_window.height
end
end
Sim! esta igual ao que eu imaginei ficou excelente: )
Ok, então vou seguir para as outras!
Edit: Eu estava aqui fazendo, e houve um problema na parte dos itens, não é nada com o script, é o tamanho, olha:
Spoiler
(http://i.imgur.com/Lin1LyD.png)
Como pode ver, a quantidade de itens sobrepõe o nome do item devido o tamanho da janela! O que quer que eu faça?
Voce pode deixar uma coluna de descrição ao inves de duas,tipo apareceria roupa de aventureiro e em baixo o escudo de aço, a janela escrito itens,armadura e etc é um pouco mais para baixo.
Hum entendi, vou fazer isso!
A mesma coisa você pode fazer na janela de equipamento,se der o mesmo problema : )
Pedido pronto!
Bem hategum rpg, seu pedido está aqui, a janela de equipamentos foi um dilema, não consegui resolver um problema, então fiz de um jeito que imagino que possa se aproximar do pedido, vou tentar descobrir uma forma de deixa-la corretamente, mas não garanto...
Enfim, o resto não foi um problema :XD:
#===============================================================================
# Kinsoyo RGSS3 Factory - Scene_Menu edit
# By: Miguel8884
#
# Não foi 100% por alguns erros que encontrei no caminho, mas tentei me
# aproximar ao máximo ao pedido!
#===============================================================================
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
#--------------------------------------------------------------------------
def initialize(x,y)
super(x, window_y, window_width, window_height)
@pending_index = -1
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da altura da janela
#--------------------------------------------------------------------------
def window_height
98 + 24
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
98
end
end
class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
#--------------------------------------------------------------------------
def initialize(x)
super(x, window_y)
select_last
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)-fitting_height(7)
end
end
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_command_window
create_status_window
create_gold_window
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_MenuStatus.new(0,0)
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de dinheiro
#--------------------------------------------------------------------------
def create_gold_window
@gold_window = Window_Gold.new
@gold_window.x = 160
@gold_window.y = Graphics.height - @gold_window.height - @status_window.height
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Criação da janela de categorias
#--------------------------------------------------------------------------
def create_category_window
@category_window = Window_ItemCategoryEdit.new
@category_window.viewport = @viewport
@category_window.help_window = @help_window
@category_window.y = Graphics.height - @help_window.height - @category_window.height
@category_window.set_handler(:ok, method(:on_category_ok))
@category_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de ajuda.
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_HelpItem.new
@help_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
@item_window = Window_ItemList.new(160, 0, Graphics.width-160, Graphics.height-96*2)
@item_window.y = Graphics.height - @help_window.height - @item_window.height
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
end
class Window_ItemCategoryEdit < Window_Command
#--------------------------------------------------------------------------
# * Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :item_window
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def visible_line_number
return 4
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@item_window.category = current_symbol if @item_window
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::item, :item)
add_command(Vocab::weapon, :weapon)
add_command(Vocab::armor, :armor)
add_command(Vocab::key_item, :key_item)
end
#--------------------------------------------------------------------------
# * Definição da janela de itens
# item_window : janela de itens
#--------------------------------------------------------------------------
def item_window=(item_window)
@item_window = item_window
update
end
end
class Window_HelpItem < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# line_number : número de linhas
#--------------------------------------------------------------------------
def initialize(line_number = 2)
super(0, window_y, Graphics.width, fitting_height(line_number))
end
#--------------------------------------------------------------------------
# * Configuração de texto
# text : texto
#--------------------------------------------------------------------------
def set_text(text)
if text != @text
@text = text
refresh
end
end
def window_y
return Graphics.height-fitting_height(2)
end
#--------------------------------------------------------------------------
# * Limpeza
#--------------------------------------------------------------------------
def clear
set_text("")
end
#--------------------------------------------------------------------------
# * Definição de item
# item : habilidades, itens, etc.
#--------------------------------------------------------------------------
def set_item(item)
set_text(item ? item.description : "")
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
contents.clear
draw_text_ex(4, 0, @text)
end
end
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Scene_Skill < Scene_ItemBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_help_window
create_status_window
create_command_window
create_item_window
@help_window.y = Graphics.height - @status_window.height - @item_window.height - @help_window.height
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_SkillStatus.new(0, Graphics.height-(98+22))
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wx = 160
ww = Graphics.width - 160
@item_window = Window_SkillList.new(wx, 0, ww, 4*24+24)
@item_window.y = Graphics.height - @status_window.height - @item_window.height
@item_window.actor = @actor
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@command_window.skill_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_SkillCommand.new(0, 0)
@command_window.y = Graphics.height - @status_window.height - (4*24+24)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.actor = @actor
@command_window.set_handler(:skill, method(:command_skill))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
end
class Scene_Equip < Scene_MenuBase
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_EquipStatus.new(0, 0)
@status_window.x = Graphics.width-@status_window.width
@status_window.y = Graphics.height-@status_window.height
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de slots
#--------------------------------------------------------------------------
def create_slot_window
wy = @command_window.y + @command_window.height
ww = Graphics.width - @status_window.width
@slot_window = Window_EquipSlot.new(0, wy, ww)
@slot_window.viewport = @viewport
@slot_window.help_window = @help_window
@slot_window.status_window = @status_window
@slot_window.actor = @actor
@slot_window.set_handler(:ok, method(:on_slot_ok))
@slot_window.set_handler(:cancel, method(:on_slot_cancel))
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
wy = @help_window.height
@command_window = Window_EquipCommandItem.new(0, wy)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.set_handler(:equip, method(:command_equip))
@command_window.set_handler(:optimize, method(:command_optimize))
@command_window.set_handler(:clear, method(:command_clear))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
#--------------------------------------------------------------------------
# * Criação da janela de item
#--------------------------------------------------------------------------
def create_item_window
wx = 0
wy = @slot_window.y + @slot_window.height
ww = Graphics.width-@status_window.width
wh = Graphics.height - wy
@item_window = Window_EquipItem.new(wx, wy, ww, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.status_window = @status_window
@item_window.actor = @actor
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@slot_window.item_window = @item_window
end
end
class Window_EquipCommandItem < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::equip2, :equip)
add_command(Vocab::optimize, :optimize)
add_command(Vocab::clear, :clear)
end
end
# Fim do script #
owww!!!
Parece perfeito!!!
+ golds
obrigado,muito obrigado :*-*:
Opa, que bom que gostou! Precisando de mais alguma coisa... Se eu puder fazer eu faço!
Double Topic mas para entregar o script! :XD:
Então ArrowPotter seu script está pronto, como eu disse por mp ele demorou mais do que devia por uma parte em que dei uma empacada mas no fim deu certo!
Então nas notas você coloca Gender=id
No id você coloca o id do gênero do item, assim quando chamar a cena de itens por gênero só vão aparecer aqueles que você definiu com tal id, pois para chamar a cena use esse comando no chamar script:
call_gitem(id)
No lugar de id você coloca o id dos itens que irão aparecer, por exemplo eu tenho lá no database
Maçã nas notas eu coloquei Gender=0
Banana nas notas Gender=0
Suco nas notas Gender=1
Então se eu abrir call_gitem(0) assim só vão aparecer a maçã e a banana, claro, caso o herói tenha!
Fiz utilizando as mesmas medidas do outro script, e para as imagens dos itens, é o mesmo esquema, nas notas coloque antes ou depois do Gender Image=id onde id é o id da imagem configurado no script!
Acho que essas foram todas as explicações que eu precisava dar, caso ocorra algum erro, ou alguma coisa que você queira mudar, me fale!
O script:
#===============================================================================
# Kinsoyo RGSS3 Factory - Scene_ItemGender
# By: Miguel8884
#
# Espero que tenha atendido ao pedido!
#===============================================================================
module Item_Menu_Gender
#--------------------------------------------------------------------------
# * Criação de variável - Não mexa
#--------------------------------------------------------------------------
Photo = Array.new
#--------------------------------------------------------------------------
# * Imagens
#--------------------------------------------------------------------------
# Posições das imagens #
Images_XY = [310,135]
Name_And_Amount_Y = [254,274]
#--------------------------------------------------------------------------
# * Vocabulário
#--------------------------------------------------------------------------
# Vocabulário para quantidade de itens #
Item_Amount_Vocab = "Possui:"
#--------------------------------------------------------------------------
# * Imagens que irão ser utilizadas para os itens
#--------------------------------------------------------------------------
Photo[0] = ""
Photo[1] = "Img1"
#--------------------------------------------------------------------------
# * Fim das configurações
#--------------------------------------------------------------------------
end
class RPG::BaseItem
#--------------------------------------------------------------------------
# * Método para pegar o gênero do item
#--------------------------------------------------------------------------
def gender
if @note.match(/Gender=(\d+)/im)
return $1
end
end
end
class Game_Interpreter
#--------------------------------------------------------------------------
# * Chamar a cena de itens por gênero
# id : Id dos itens que irão aparecer
#--------------------------------------------------------------------------
def call_gitem(id)
$gst_igender = id
SceneManager.call(Scene_ItemGender)
end
end
class Window_ItemHelp < Window_Base
#--------------------------------------------------------------------------
# * Variável pública
#--------------------------------------------------------------------------
attr_accessor :item
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
@item = 0
super(0,0,Graphics.width,fitting_height(2))
end
#--------------------------------------------------------------------------
# * Atualização do objeto
#--------------------------------------------------------------------------
def update
super
set_text
end
#--------------------------------------------------------------------------
# * Configuração de texto
#--------------------------------------------------------------------------
def set_text
self.contents.clear
if @item != 0 and @item != nil
draw_text_ex(0,0,@item.description)
end
end
end
class Window_ItemGlist < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
# height : altura
#--------------------------------------------------------------------------
def initialize(x, y, width, height)
super
@data = []
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def item_width
return 24
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
return 24
end
#--------------------------------------------------------------------------
# * Aquisição do espaçamento entre os itens
#--------------------------------------------------------------------------
def spacing
return 15
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 7
end
#--------------------------------------------------------------------------
# * Aquisição do número máximo de itens
#--------------------------------------------------------------------------
def item_max
@data ? @data.size : 1
end
#--------------------------------------------------------------------------
# * Aquisição das informações do item
#--------------------------------------------------------------------------
def item
@data && index >= 0 ? @data[index] : nil
end
#--------------------------------------------------------------------------
# * Definição de habilitação de seleção
#--------------------------------------------------------------------------
def current_item_enabled?
enable?(@data[index])
end
#--------------------------------------------------------------------------
# * Definição de habilitação do item
# item : item
#--------------------------------------------------------------------------
def enable?(item)
$game_party.usable?(item)
end
#--------------------------------------------------------------------------
# * Criação da lista de itens
#--------------------------------------------------------------------------
def make_item_list
@data = $game_party.items.select{|item| item.gender.to_i == $gst_igender}
end
#--------------------------------------------------------------------------
# * Retorno à seleção anterior
#--------------------------------------------------------------------------
def select_last
select(index)
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
rect = item_rect(index)
rect.width -= 4
draw_icon(item.icon_index, rect.x, rect.y, enable?(item))
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
make_item_list
create_contents
draw_all_items
end
end
class Scene_ItemGender < Scene_ItemBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_window_help
create_item_list
create_item_data
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@help_window.item = @item_window.item
@data_window.actual_item = @item_window.item
end
#--------------------------------------------------------------------------
# * Finalização do processo
#--------------------------------------------------------------------------
def terminate
super
dispose_all_windows
end
#--------------------------------------------------------------------------
# * Criação da janela de informação
#--------------------------------------------------------------------------
def create_window_help
@help_window = Window_ItemHelp.new
@help_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_list
wh = Graphics.height - @help_window.height
@item_window = Window_ItemGlist.new(0, @help_window.height, Graphics.width-252, wh)
@help_window.item = @item_window.item
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@item_window.viewport = @viewport
@item_window.activate
@item_window.select(0)
@item_window.refresh
end
#--------------------------------------------------------------------------
# * Criação da janela dos dados dos itens
#--------------------------------------------------------------------------
def create_item_data
wy = @help_window.height
wh = Graphics.height - wy
@data_window = Window_ItemDataGender.new(@item_window.width,wy,Graphics.width-@item_window.width,wh,@viewport)
@data_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Item [Confirmação]
#--------------------------------------------------------------------------
def on_item_ok
$game_party.last_item.object = item
determine_item
end
#--------------------------------------------------------------------------
# * Item [Cancelamento]
#--------------------------------------------------------------------------
def on_item_cancel
@item_window.unselect
return_scene
end
#--------------------------------------------------------------------------
# * Execução de SE para o item
#--------------------------------------------------------------------------
def play_se_for_item
Sound.play_use_item
end
#--------------------------------------------------------------------------
# * Apagar todas as janelas
#--------------------------------------------------------------------------
def dispose_all_windows
@help_window.dispose
@item_window.dispose
@data_window.dispose
end
#--------------------------------------------------------------------------
# * Usando um item
#--------------------------------------------------------------------------
def use_item
super
@item_window.redraw_current_item
end
end
class Window_ItemDataGender < Window_Base
attr_accessor :actual_item
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
# height : altura
# viewport : camada
#--------------------------------------------------------------------------
def initialize(x,y,width,height,viewport)
super(x,y,width,height)
@actual_item = 0
@image = Sprite.new(viewport)
refresh
end
#--------------------------------------------------------------------------
# * Atualização do objeto
#--------------------------------------------------------------------------
def update
super
refresh
end
#--------------------------------------------------------------------------
# * Criação e renovação do conteúdo
#--------------------------------------------------------------------------
def refresh
self.contents.clear
if @actual_item != 0 and @actual_item != nil
draw_text(0,Item_Menu_Gender::Name_And_Amount_Y[0],self.width,24,@actual_item.name)
draw_text(0,Item_Menu_Gender::Name_And_Amount_Y[1],self.width,24,"#{Item_Menu_Gender::Item_Amount_Vocab} #{sprintf("%2d",$game_party.item_number(@actual_item))}")
if @actual_item.note.match(/Image=(\d+)/im)
image_note = Item_Menu_Gender::Photo[$1.to_i]
else
image_note = Item_Menu_Gender::Photo[0]
end
@image.bitmap = Cache.picture(image_note)
@image.x = Item_Menu_Gender::Images_XY[0]
@image.z = 100
@image.y = Item_Menu_Gender::Images_XY[1]
end
end
#--------------------------------------------------------------------------
# * Apagar as imagens
#--------------------------------------------------------------------------
def dispose_images
@image.bitmap.dispose
@image.dispose
end
end
# Fim do script #
Ei amigo, tenho um bug no script, quando vou usar magia de cura pelo menu.
(http://i.imgur.com/x8L5KFZ.png)
pode consertar?melhorar a aparencia, que parece que ele corta um pedaço do menu.
Então, hora que avistei esse bug, já tinha ido! Vou tentar consertar aqui e te passo :ok:
Edit:
Pronto, dei uma resolvida meio que na gambiarra mas resolvi:
#===============================================================================
# Kinsoyo RGSS3 Factory - Scene_Menu edit
# By: Miguel8884
#
# Não foi 100% por alguns erros que encontrei no caminho, mas tentei me
# aproximar ao máximo ao pedido!
#===============================================================================
class Scene_ItemBase < Scene_MenuBase
#--------------------------------------------------------------------------
# * Exibição da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def show_sub_window(window)
width_remain = Graphics.width - window.width
window.x = 0
window.y = 0
window.show.activate
end
#--------------------------------------------------------------------------
# * Ocultação da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def hide_sub_window(window)
window.hide.deactivate
activate_item_window
end
end
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
#--------------------------------------------------------------------------
def initialize(x,y)
super(x, window_y, window_width, window_height)
@pending_index = -1
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da altura da janela
#--------------------------------------------------------------------------
def window_height
98 + 24
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
98
end
end
class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
#--------------------------------------------------------------------------
def initialize(x)
super(x, window_y)
select_last
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)-fitting_height(7)
end
end
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_command_window
create_status_window
create_gold_window
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_MenuStatus.new(0,0)
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de dinheiro
#--------------------------------------------------------------------------
def create_gold_window
@gold_window = Window_Gold.new
@gold_window.x = 160
@gold_window.y = Graphics.height - @gold_window.height - @status_window.height
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Criação da janela de categorias
#--------------------------------------------------------------------------
def create_category_window
@category_window = Window_ItemCategoryEdit.new
@category_window.viewport = @viewport
@category_window.help_window = @help_window
@category_window.y = Graphics.height - @help_window.height - @category_window.height
@category_window.set_handler(:ok, method(:on_category_ok))
@category_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de ajuda.
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_HelpItem.new
@help_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
@item_window = Window_ItemList.new(160, 0, Graphics.width-160, Graphics.height-96*2)
@item_window.y = Graphics.height - @help_window.height - @item_window.height
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
end
class Window_ItemCategoryEdit < Window_Command
#--------------------------------------------------------------------------
# * Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :item_window
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def visible_line_number
return 4
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@item_window.category = current_symbol if @item_window
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::item, :item)
add_command(Vocab::weapon, :weapon)
add_command(Vocab::armor, :armor)
add_command(Vocab::key_item, :key_item)
end
#--------------------------------------------------------------------------
# * Definição da janela de itens
# item_window : janela de itens
#--------------------------------------------------------------------------
def item_window=(item_window)
@item_window = item_window
update
end
end
class Window_HelpItem < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# line_number : número de linhas
#--------------------------------------------------------------------------
def initialize(line_number = 2)
super(0, window_y, Graphics.width, fitting_height(line_number))
end
#--------------------------------------------------------------------------
# * Configuração de texto
# text : texto
#--------------------------------------------------------------------------
def set_text(text)
if text != @text
@text = text
refresh
end
end
def window_y
return Graphics.height-fitting_height(2)
end
#--------------------------------------------------------------------------
# * Limpeza
#--------------------------------------------------------------------------
def clear
set_text("")
end
#--------------------------------------------------------------------------
# * Definição de item
# item : habilidades, itens, etc.
#--------------------------------------------------------------------------
def set_item(item)
set_text(item ? item.description : "")
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
contents.clear
draw_text_ex(4, 0, @text)
end
end
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Scene_Skill < Scene_ItemBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_help_window
create_status_window
create_command_window
create_item_window
@help_window.y = Graphics.height - @status_window.height - @item_window.height - @help_window.height
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_SkillStatus.new(0, Graphics.height-(98+22))
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wx = 160
ww = Graphics.width - 160
@item_window = Window_SkillList.new(wx, 0, ww, 4*24+24)
@item_window.y = Graphics.height - @status_window.height - @item_window.height
@item_window.actor = @actor
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@command_window.skill_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_SkillCommand.new(0, 0)
@command_window.y = Graphics.height - @status_window.height - (4*24+24)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.actor = @actor
@command_window.set_handler(:skill, method(:command_skill))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
end
class Scene_Equip < Scene_MenuBase
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_EquipStatus.new(0, 0)
@status_window.x = Graphics.width-@status_window.width
@status_window.y = Graphics.height-@status_window.height
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de slots
#--------------------------------------------------------------------------
def create_slot_window
wy = @command_window.y + @command_window.height
ww = Graphics.width - @status_window.width
@slot_window = Window_EquipSlot.new(0, wy, ww)
@slot_window.viewport = @viewport
@slot_window.help_window = @help_window
@slot_window.status_window = @status_window
@slot_window.actor = @actor
@slot_window.set_handler(:ok, method(:on_slot_ok))
@slot_window.set_handler(:cancel, method(:on_slot_cancel))
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
wy = @help_window.height
@command_window = Window_EquipCommandItem.new(0, wy)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.set_handler(:equip, method(:command_equip))
@command_window.set_handler(:optimize, method(:command_optimize))
@command_window.set_handler(:clear, method(:command_clear))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
#--------------------------------------------------------------------------
# * Criação da janela de item
#--------------------------------------------------------------------------
def create_item_window
wx = 0
wy = @slot_window.y + @slot_window.height
ww = Graphics.width-@status_window.width
wh = Graphics.height - wy
@item_window = Window_EquipItem.new(wx, wy, ww, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.status_window = @status_window
@item_window.actor = @actor
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@slot_window.item_window = @item_window
end
end
class Window_EquipCommandItem < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::equip2, :equip)
add_command(Vocab::optimize, :optimize)
add_command(Vocab::clear, :clear)
end
end
# Fim do script #
Legal, fico aguardando : )
edt: :*-*: agora esta perfeito!!! : )
+golds
Bem é para substituir o outro script? Tipo e como eu adiciono Gêneros? Fiquei tonto rsrsrs mas valeu!
Não não, não substitua o outro script, este adiciona a opção de menu por gêneros, então você faz o seguinte, no chamar script, você coloca esse comando e então ele chama a cena e já com os itens do gênero definido, que é o id!
call_gitem(id)
No id você coloca o número de id que apenas os itens que tiverem aquele id no banco de dados nas notas, vão aparecer! É meio dificil de explicar kkk. Tente ver se entendeu!
Ufa antes de vc responder eu já tinha descoberto hihihi tão fácil e eu quebrando a cabeça. Valeu o script funcionou perfeitamente. Pena que eu tenha que colocar as imagens neste script também. Só uma dúvida... meu jogo terá centenas de itens, o Editor de scripts não tem limite de linhas tem? Porquê vou colocar imagens em mais de 400 itens.
Não fica tranquilo, não limite de linhas kkk!
O seu novo script "GST Distribute Points System" não funciona com o script "Kinsoyo RGSS3 Factory - Scene_Menu edit" da um bug quando se abre o menu, mesmo com a opção de aparecer no menu como false. Pode dar um jeito de fazer funcionar ? : )
Okay... Vou ver aqui o que pode ter acontecido! :ok:
Edit:
Já descobri o que está acontecendo, é que o script que eu te fiz, ele muda a cena que eu mudo nesse outro script, de qualquer forma, arrumei aqui, compatível com o outro script!
#===============================================================================
# Kinsoyo RGSS3 Factory - Scene_Menu edit
# By: Miguel8884
#
# Não foi 100% por alguns erros que encontrei no caminho, mas tentei me
# aproximar ao máximo ao pedido!
#===============================================================================
class Scene_ItemBase < Scene_MenuBase
#--------------------------------------------------------------------------
# * Exibição da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def show_sub_window(window)
width_remain = Graphics.width - window.width
window.x = 0
window.y = 0
window.show.activate
end
#--------------------------------------------------------------------------
# * Ocultação da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def hide_sub_window(window)
window.hide.deactivate
activate_item_window
end
end
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
#--------------------------------------------------------------------------
def initialize(x,y)
super(x, window_y, window_width, window_height)
@pending_index = -1
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da altura da janela
#--------------------------------------------------------------------------
def window_height
98 + 24
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
98
end
end
class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
#--------------------------------------------------------------------------
def initialize(x)
super(x, window_y)
select_last
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
if Distribute_Config::Put_On_Menu
Graphics.height-(98+24)-fitting_height(8)
else
Graphics.height-(98+24)-fitting_height(7)
end
end
end
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_command_window
create_status_window
create_gold_window
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_MenuStatus.new(0,0)
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
if Distribute_Config::Put_On_Menu
@command_window.set_handler(:dist, method(:command_personal))
end
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de dinheiro
#--------------------------------------------------------------------------
def create_gold_window
@gold_window = Window_Gold.new
@gold_window.x = 160
@gold_window.y = Graphics.height - @gold_window.height - @status_window.height
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Criação da janela de categorias
#--------------------------------------------------------------------------
def create_category_window
@category_window = Window_ItemCategoryEdit.new
@category_window.viewport = @viewport
@category_window.help_window = @help_window
@category_window.y = Graphics.height - @help_window.height - @category_window.height
@category_window.set_handler(:ok, method(:on_category_ok))
@category_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de ajuda.
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_HelpItem.new
@help_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
@item_window = Window_ItemList.new(160, 0, Graphics.width-160, Graphics.height-96*2)
@item_window.y = Graphics.height - @help_window.height - @item_window.height
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
end
class Window_ItemCategoryEdit < Window_Command
#--------------------------------------------------------------------------
# * Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :item_window
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def visible_line_number
return 4
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@item_window.category = current_symbol if @item_window
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::item, :item)
add_command(Vocab::weapon, :weapon)
add_command(Vocab::armor, :armor)
add_command(Vocab::key_item, :key_item)
end
#--------------------------------------------------------------------------
# * Definição da janela de itens
# item_window : janela de itens
#--------------------------------------------------------------------------
def item_window=(item_window)
@item_window = item_window
update
end
end
class Window_HelpItem < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# line_number : número de linhas
#--------------------------------------------------------------------------
def initialize(line_number = 2)
super(0, window_y, Graphics.width, fitting_height(line_number))
end
#--------------------------------------------------------------------------
# * Configuração de texto
# text : texto
#--------------------------------------------------------------------------
def set_text(text)
if text != @text
@text = text
refresh
end
end
def window_y
return Graphics.height-fitting_height(2)
end
#--------------------------------------------------------------------------
# * Limpeza
#--------------------------------------------------------------------------
def clear
set_text("")
end
#--------------------------------------------------------------------------
# * Definição de item
# item : habilidades, itens, etc.
#--------------------------------------------------------------------------
def set_item(item)
set_text(item ? item.description : "")
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
contents.clear
draw_text_ex(4, 0, @text)
end
end
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Scene_Skill < Scene_ItemBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_help_window
create_status_window
create_command_window
create_item_window
@help_window.y = Graphics.height - @status_window.height - @item_window.height - @help_window.height
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_SkillStatus.new(0, Graphics.height-(98+22))
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wx = 160
ww = Graphics.width - 160
@item_window = Window_SkillList.new(wx, 0, ww, 4*24+24)
@item_window.y = Graphics.height - @status_window.height - @item_window.height
@item_window.actor = @actor
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@command_window.skill_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_SkillCommand.new(0, 0)
@command_window.y = Graphics.height - @status_window.height - (4*24+24)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.actor = @actor
@command_window.set_handler(:skill, method(:command_skill))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
end
class Scene_Equip < Scene_MenuBase
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_EquipStatus.new(0, 0)
@status_window.x = Graphics.width-@status_window.width
@status_window.y = Graphics.height-@status_window.height
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de slots
#--------------------------------------------------------------------------
def create_slot_window
wy = @command_window.y + @command_window.height
ww = Graphics.width - @status_window.width
@slot_window = Window_EquipSlot.new(0, wy, ww)
@slot_window.viewport = @viewport
@slot_window.help_window = @help_window
@slot_window.status_window = @status_window
@slot_window.actor = @actor
@slot_window.set_handler(:ok, method(:on_slot_ok))
@slot_window.set_handler(:cancel, method(:on_slot_cancel))
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
wy = @help_window.height
@command_window = Window_EquipCommandItem.new(0, wy)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.set_handler(:equip, method(:command_equip))
@command_window.set_handler(:optimize, method(:command_optimize))
@command_window.set_handler(:clear, method(:command_clear))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
#--------------------------------------------------------------------------
# * Criação da janela de item
#--------------------------------------------------------------------------
def create_item_window
wx = 0
wy = @slot_window.y + @slot_window.height
ww = Graphics.width-@status_window.width
wh = Graphics.height - wy
@item_window = Window_EquipItem.new(wx, wy, ww, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.status_window = @status_window
@item_window.actor = @actor
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@slot_window.item_window = @item_window
end
end
class Window_EquipCommandItem < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::equip2, :equip)
add_command(Vocab::optimize, :optimize)
add_command(Vocab::clear, :clear)
end
end
# Fim do script #
Não funcionou
o erro ocorre Linha 953 do GST Distribute Points System
(http://i.imgur.com/eGZFFZj.png)
Opa, deu errado no seu e não no meu por que meu script de distribuir pontos ta antes do de menu, mas é só substituir o de distribuir por esse aqui, era só definir uma coisa, se der mais erros, me avise!
#===============================================================================
# ** GST Distribute Points System
# Autor: miguel8884
#-------------------------------------------------------------------------------
# Data de lançamento: 10/09/2014
# Versão: 1.0
#-------------------------------------------------------------------------------
# Dependências:
# * Nenhuma
#-------------------------------------------------------------------------------
# Descrição:
#
# O script permite que você tenha uma cena de distribuição de pontos para todos
# os heróis, onde eles poderam aumentar seus atributos com os pontos.
#-------------------------------------------------------------------------------
# Características:
# * Possibilidade de adição no menu!
# * Sem lag!
# * Todos os heróis podem distribuir pontos!
# * Alta configuração!
# * Fácil adição de pontos!
#-------------------------------------------------------------------------------
# Log:
# v1.0
# 10/09/2014 - Script lançado!
#-------------------------------------------------------------------------------
# - Chamando a cena por eventos, adicionando e retirando pontos -
# Para chamar a cena por eventos, apenas use no chamar script:
# call_distribute(id)
# No lugar de id coloque o id do herói na equipe, começando do 0 até 3
#
# Para adcionar pontos, apenas use no chamar script:
# add_points(amount,actor)
# No lugar de amount coloque a quantidade que quer aumentar
# No lugar de actor coloque o id do herói na equipe, do 0 até 3
#
# Para retirar, use o mesmo comando, mas no amount coloque o número negativo
# de acordo com o tanto que quer tirar
#===============================================================================
module Distribute_Config
#--------------------------------------------------------------------------
# * Criação de variáveis - Não mexa
#--------------------------------------------------------------------------
Param_Conf = Hash.new
Actor = Array.new
#--------------------------------------------------------------------------
# * Configuração - Cor
#--------------------------------------------------------------------------
# Cor verde no texto #
Green_Color = Color.new(120,230,120)
#--------------------------------------------------------------------------
# * Configuração Geral
#--------------------------------------------------------------------------
# Colocar opção no menu #
Put_On_Menu = true
# Recuperar jogador após aumentar hp ou mp máximo? #
Heal_Player = true
# Nome do SE após o comando não ter condições de ser executado #
Wrong_Select = "buzzer1"
# Pontos que cada herói começa #
Initial_Points = 36
#--------------------------------------------------------------------------
# * Vocabulário
#--------------------------------------------------------------------------
# Vocabulário para preço #
Price_Vocab = "Preço: "
# Vocabulário do topo #
Top_Vocab = "Distribuir Pontos"
# Vocabulário para pontos
Points_Vocab = "Pontos: "
# Vocabulário no menu
Menu_Vocab = "Distribuir"
#--------------------------------------------------------------------------
# * Configurações - Habilidades (por herói)
#--------------------------------------------------------------------------
#--------------------------------------------------------------------------
# * Instruções
# \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
# Você edita aqui as configurações de preço nome e outros para cada habilidade
# do herói em questão seguindo pelo id de cada uma delas!
#
# A primeira coisa que temos é Actor[id] = [
# Aqui nós colocamos no lugar de id o número do jogador na equipe, começando
# do 0 e terminando no 3 normalmente. No script você já terá todos os Actor
# configurados em sequência, é só editar um por um!
#
# Param_Conf[id] = { é a próxima configuração
# Aqui teremos de colocar no lugar de id o id do parâmetro que vamos utilizar,
# existem 8 parâmetros sendo que a contagem começa do 0, assim teremos até
# o parâmetro 7, seguindo essa sequência:
# 0 = HP Máximo
# 1 = MP Máximo
# 2 = Ataque
# 3 = Defesa
# 4 = Ataque Mágico
# 5 = Defesa Mágica
# 6 = Agilidade
# 7 = Sorte
#
# Dentro do Param_Config teremos as configurações do parâmetro atual, no caso
# seu id correspondente a tabela acima.
# vocab: "vocabulário para o parâmetro",
# icon: id do ícone do parâmetro,
# point_value: valor adicionado no parâmetro a cada ponto gasto,
# point_price: pontos gastos em cada confirmação,
# inc_exp: adicionar experiência no herói em questão ao aumentar algum
# parâmetro, caso não queira coloque 0,
# change_price_level: nível em que o herói em questão deve estar para os
# pontos ficarem mais caros ou darem mais a cada gasto,
# change_price_points: pontos adcionados que seram gastos após o nível ser
# ultrapassado, ou seja, quanto ficará mais caro,
# change_price_value: após ser efetuada a ultrapassagem de nível quanto
# herói receberá a mais em cada compra,
# des: descrição do parâmetro,
#
# OBS: Nunca esqueça de colocar a vírgula ao final de todas as configurações
#
# Exemplo:
#
# Param_Conf[0] = {
# vocab: "HP Máximo",
# icon: 1,
# point_value: 36,
# point_price: 1,
# inc_exp: 50,
# change_price_level: 3,
# change_price_points: 2,
# change_price_value: 100,
# des: "Dizem que um guerreiro com grande vida tem mais
# chances de sobreviver"
# },
#--------------------------------------------------------------------------
Actor[0] = [
Param_Conf[0] = {
vocab: "HP Máximo",
icon: 1,
point_value: 36,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 100,
des: "Dizem que um guerreiro com grande vida tem mais
chances de sobreviver"
},
Param_Conf[1] = {
vocab: "MP Máximo",
icon: 2,
point_value: 4,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Um guerreiro sem mana, não tem como chegar as mais
altas magias de um grande mago"
},
Param_Conf[2] = {
vocab: "Ataque",
icon: 3,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Quanto mais forte, mais se sobresaíra"
},
Param_Conf[3] = {
vocab: "Defesa",
icon: 4,
point_value: 3,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "O ataque é importante, mas alguém com defesa não
apanha tão fácil"
},
Param_Conf[4] = {
vocab: "Ataque Mágico",
icon: 5,
point_value: 1,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "A força e a magia são as melhores aliadas"
},
Param_Conf[5] = {
vocab: "Defesa Mágica",
icon: 6,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Usar a magia para se proteger, apenas sabios fazem
isso"
},
Param_Conf[6] = {
vocab: "Agilidade",
icon: 7,
point_value: 4,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Como atacam algo que não conseguem ver?"
},
Param_Conf[7] = {
vocab: "Sorte",
icon: 8,
point_value: 7,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Se a sorte está do seu lado, tudo será mais fácil"
},
]
#--------------------------------------------------------------------------
# * Herói 2
#--------------------------------------------------------------------------
Actor[1] = [
Param_Conf[0] = {
vocab: "HP Máximo",
icon: 1,
point_value: 36,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 100,
des: "Dizem que um guerreiro com grande vida tem mais
chances de sobreviver"
},
Param_Conf[1] = {
vocab: "MP Máximo",
icon: 2,
point_value: 4,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Um guerreiro sem mana, não tem como chegar as mais
altas magias de um grande mago"
},
Param_Conf[2] = {
vocab: "Ataque",
icon: 3,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Quanto mais forte, mais se sobresaíra"
},
Param_Conf[3] = {
vocab: "Defesa",
icon: 4,
point_value: 3,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "O ataque é importante, mas alguém com defesa não
apanha tão fácil"
},
Param_Conf[4] = {
vocab: "Ataque Mágico",
icon: 5,
point_value: 1,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "A força e a magia são as melhores aliadas"
},
Param_Conf[5] = {
vocab: "Defesa Mágica",
icon: 6,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Usar a magia para se proteger, apenas sabios fazem
isso"
},
Param_Conf[6] = {
vocab: "Agilidade",
icon: 7,
point_value: 4,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Como atacam algo que não conseguem ver?"
},
Param_Conf[7] = {
vocab: "Sorte",
icon: 8,
point_value: 7,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Se a sorte está do seu lado, tudo será mais fácil"
},
]
#--------------------------------------------------------------------------
# * Herói 3
#--------------------------------------------------------------------------
Actor[2] = [
Param_Conf[0] = {
vocab: "HP Máximo",
icon: 1,
point_value: 36,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Dizem que um guerreiro com grande vida tem mais
chances de sobreviver"
},
Param_Conf[1] = {
vocab: "MP Máximo",
icon: 2,
point_value: 4,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Um guerreiro sem mana, não tem como chegar as mais
altas magias de um grande mago"
},
Param_Conf[2] = {
vocab: "Ataque",
icon: 3,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Quanto mais forte, mais se sobresaíra"
},
Param_Conf[3] = {
vocab: "Defesa",
icon: 4,
point_value: 3,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "O ataque é importante, mas alguém com defesa não
apanha tão fácil"
},
Param_Conf[4] = {
vocab: "Ataque Mágico",
icon: 5,
point_value: 1,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "A força e a magia são as melhores aliadas"
},
Param_Conf[5] = {
vocab: "Defesa Mágica",
icon: 6,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Usar a magia para se proteger, apenas sabios fazem
isso"
},
Param_Conf[6] = {
vocab: "Agilidade",
icon: 7,
point_value: 4,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Como atacam algo que não conseguem ver?"
},
Param_Conf[7] = {
vocab: "Sorte",
icon: 8,
point_value: 7,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Se a sorte está do seu lado, tudo será mais fácil"
},
]
#--------------------------------------------------------------------------
# * Herói 4
#--------------------------------------------------------------------------
Actor[3] = [
Param_Conf[0] = {
vocab: "HP Máximo",
icon: 1,
point_value: 36,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Dizem que um guerreiro com grande vida tem mais
chances de sobreviver"
},
Param_Conf[1] = {
vocab: "MP Máximo",
icon: 2,
point_value: 4,
point_price: 1,
inc_exp: 50,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Um guerreiro sem mana, não tem como chegar as mais
altas magias de um grande mago"
},
Param_Conf[2] = {
vocab: "Ataque",
icon: 3,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Quanto mais forte, mais se sobresaíra"
},
Param_Conf[3] = {
vocab: "Defesa",
icon: 4,
point_value: 3,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "O ataque é importante, mas alguém com defesa não
apanha tão fácil"
},
Param_Conf[4] = {
vocab: "Ataque Mágico",
icon: 5,
point_value: 1,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "A força e a magia são as melhores aliadas"
},
Param_Conf[5] = {
vocab: "Defesa Mágica",
icon: 6,
point_value: 2,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Usar a magia para se proteger, apenas sabios fazem
isso"
},
Param_Conf[6] = {
vocab: "Agilidade",
icon: 7,
point_value: 4,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Como atacam algo que não conseguem ver?"
},
Param_Conf[7] = {
vocab: "Sorte",
icon: 8,
point_value: 7,
point_price: 1,
inc_exp: 0,
change_price_level: 3,
change_price_points: 2,
change_price_value: 7,
des: "Se a sorte está do seu lado, tudo será mais fácil"
},
]
#--------------------------------------------------------------------------
# * Fim das configurações
#--------------------------------------------------------------------------
end
class Game_Interpreter
#--------------------------------------------------------------------------
# * Chamar janela de distribuição
# actor : personagem da janela
#--------------------------------------------------------------------------
def call_distribute(actor)
$gst_actor = actor
SceneManager.call(Scene_Distribute)
end
#--------------------------------------------------------------------------
# * Aumentar pontos
# actor : personagem
# amount : quantidade
#--------------------------------------------------------------------------
def add_points(amount,actor)
$game_party.members[actor].points += amount
end
end
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Variável pública
#--------------------------------------------------------------------------
attr_accessor :points
#--------------------------------------------------------------------------
# * Alias
#--------------------------------------------------------------------------
alias gst_actor_dist_ini initialize
#--------------------------------------------------------------------------
# * Inicialização do objeto
# actor_id : ID do herói
#--------------------------------------------------------------------------
def initialize(actor_id)
gst_actor_dist_ini(actor_id)
@points = Distribute_Config::Initial_Points
end
end
class Window_DistDescription < Window_Base
#--------------------------------------------------------------------------
# * Variável pública
#--------------------------------------------------------------------------
attr_accessor :id
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura da janela
# height : altura da janela
#--------------------------------------------------------------------------
def initialize(x,y,width,height)
super(x,y,width,height)
@id = 0
set_text
end
#--------------------------------------------------------------------------
# * Fazer texto
#--------------------------------------------------------------------------
def set_text
self.contents.clear
draw_text_ex(0,0,Distribute_Config::Param_Conf[@id][:des])
end
end
class Window_DistParams < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura da janela
#--------------------------------------------------------------------------
def initialize(x,y,height)
super(x,y,window_width,height)
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
Graphics.width
end
#--------------------------------------------------------------------------
# * Aquisição do número máximo de itens
#--------------------------------------------------------------------------
def item_max
return 8
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
return 24
end
#--------------------------------------------------------------------------
# * Desenho de um item
# index : índice do item
#--------------------------------------------------------------------------
def draw_item(index)
case index
when 0
paramw = Distribute_Config::Actor[$gst_actor][0]
param_id = 0
when 1
paramw = Distribute_Config::Actor[$gst_actor][1]
param_id = 1
when 2
paramw = Distribute_Config::Actor[$gst_actor][2]
param_id = 2
when 3
paramw = Distribute_Config::Actor[$gst_actor][3]
param_id = 3
when 4
paramw = Distribute_Config::Actor[$gst_actor][4]
param_id = 4
when 5
paramw = Distribute_Config::Actor[$gst_actor][5]
param_id = 5
when 6
paramw = Distribute_Config::Actor[$gst_actor][6]
param_id = 6
when 7
paramw = Distribute_Config::Actor[$gst_actor][7]
param_id = 7
end
if $game_party.members[$gst_actor].level >= paramw[:change_price_level]
draw_icon(paramw[:icon],5,index*24)
draw_text(29,index*24,Graphics.width-200,24,paramw[:vocab])
draw_text(200,index*24,140,24,$game_party.members[$gst_actor].param(param_id))
draw_text(390,index*24,140,24,"#{Distribute_Config::Price_Vocab}#{paramw[:point_price] + paramw[:change_price_points]}")
change_color(Distribute_Config::Green_Color)
draw_text(300,index*24,140,24,$game_party.members[$gst_actor].param(param_id) + paramw[:point_value] + paramw[:change_price_value])
draw_right_arrow(250,index*24)
change_color(normal_color)
else
draw_icon(paramw[:icon],5,index*24)
draw_text(29,index*24,Graphics.width-200,24,paramw[:vocab])
draw_text(200,index*24,140,24,$game_party.members[$gst_actor].param(param_id))
draw_text(390,index*24,140,24,"#{Distribute_Config::Price_Vocab}#{paramw[:point_price]}")
change_color(Distribute_Config::Green_Color)
draw_text(300,index*24,140,24,$game_party.members[$gst_actor].param(param_id) + paramw[:point_value])
draw_right_arrow(250,index*24)
change_color(normal_color)
end
end
#--------------------------------------------------------------------------
# * Desenho de flecha
# x : coordenada X
# y : coordenada Y
#--------------------------------------------------------------------------
def draw_right_arrow(x, y)
change_color(system_color)
draw_text(x, y, 22, line_height, "→", 1)
end
#--------------------------------------------------------------------------
# * Retorno à seleção anterior
#--------------------------------------------------------------------------
def select_last
select(index)
end
end
class Window_DistStatus < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0,fitting_height(1),Graphics.width-200,fitting_height(1))
@actor = $game_party.members[$gst_actor]
refresh
end
#--------------------------------------------------------------------------
# * Renovar conteúdo
#--------------------------------------------------------------------------
def refresh
self.contents.clear
draw_actor_hp(@actor,0,0)
draw_actor_mp(@actor,150,0)
end
end
class Window_DistTop < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0,0,Graphics.width,fitting_height(1))
refresh
end
#--------------------------------------------------------------------------
# * Renovar conteúdo
#--------------------------------------------------------------------------
def refresh
draw_text(-10,0,Graphics.width,24,Distribute_Config::Top_Vocab,1)
end
end
class Window_DistPoints < Window_Base
#--------------------------------------------------------------------------
# * Variável pública
#--------------------------------------------------------------------------
attr_accessor :actor
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura da janela
# height : altura da janela
#--------------------------------------------------------------------------
def initialize(x,y,width,height)
super(x,y,width,height)
@actor = $game_party.members[$gst_actor]
refresh
end
#--------------------------------------------------------------------------
# * Renovar conteúdo
#--------------------------------------------------------------------------
def refresh
self.contents.clear
draw_text(0,0,self.width,24,"#{Distribute_Config::Points_Vocab}#{@actor.points}")
end
end
class Scene_Distribute < Scene_Base
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
@switch = false
create_background
create_status_window
create_points_window
create_top_window
create_param_list
create_description_window
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@des_window.id = @param_window.index
@des_window.set_text
end
#--------------------------------------------------------------------------
# * Finalização do processo
#--------------------------------------------------------------------------
def terminate
super
dispose_background
dispose_all_windows
end
#--------------------------------------------------------------------------
# * Criar janela de dados do herói
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_DistStatus.new
end
#--------------------------------------------------------------------------
# * Criar janela superior
#--------------------------------------------------------------------------
def create_top_window
@top_window = Window_DistTop.new
end
#--------------------------------------------------------------------------
# * Criar janela de pontos
#--------------------------------------------------------------------------
def create_points_window
wx = @status_window.width
wy = @status_window.y
wh = @status_window.height
ww = Graphics.width - @status_window.width
@points_window = Window_DistPoints.new(wx,wy,ww,wh)
end
#--------------------------------------------------------------------------
# * Criar janela da lista de paramêtros do herói
#--------------------------------------------------------------------------
def create_param_list
wx = 0
wy = @points_window.y + @points_window.height
wh = Graphics.height - @points_window.height - @top_window.height - 96
@param_window = Window_DistParams.new(wx,wy,wh)
@param_window.set_handler(:ok,method(:on_increase_ok))
@param_window.set_handler(:cancel,method(:on_cancel))
@param_window.activate
@param_window.select(0)
end
#--------------------------------------------------------------------------
# * Criar janela de descrição
#--------------------------------------------------------------------------
def create_description_window
wx = 0
wy = @param_window.height + 96
ww = Graphics.width
wh = Graphics.height - @param_window.height - 96
@des_window = Window_DistDescription.new(wx,wy,ww,wh)
end
#--------------------------------------------------------------------------
# * Ao confirmar na lista
#--------------------------------------------------------------------------
def on_increase_ok
case @param_window.index
when 0
paramw = Distribute_Config::Actor[$gst_actor][0]
param_id = 0
when 1
paramw = Distribute_Config::Actor[$gst_actor][1]
param_id = 1
when 2
paramw = Distribute_Config::Actor[$gst_actor][2]
param_id = 2
when 3
paramw = Distribute_Config::Actor[$gst_actor][3]
param_id = 3
when 4
paramw = Distribute_Config::Actor[$gst_actor][4]
param_id = 4
when 5
paramw = Distribute_Config::Actor[$gst_actor][5]
param_id = 5
when 6
paramw = Distribute_Config::Actor[$gst_actor][6]
param_id = 6
when 7
paramw = Distribute_Config::Actor[$gst_actor][7]
param_id = 7
end
if $game_party.members[$gst_actor].level >= paramw[:change_price_level]
@param_window.refresh
if $game_party.members[$gst_actor].points >= paramw[:point_price] + paramw[:change_price_points]
$game_party.members[$gst_actor].points -= paramw[:point_price] + paramw[:change_price_points]
$game_party.members[$gst_actor].add_param(param_id,paramw[:point_value] + paramw[:change_price_value])
$game_party.members[$gst_actor].gain_exp(paramw[:inc_exp])
if Distribute_Config::Heal_Player
$game_party.members[$gst_actor].hp = $game_party.members[$gst_actor].mhp
$game_party.members[$gst_actor].mp = $game_party.members[$gst_actor].mmp
end
@param_window.activate
@param_window.select_last
else
RPG::SE.new(Distribute_Config::Wrong_Select,80).play
@param_window.activate
@param_window.select_last
end
else
if $game_party.members[$gst_actor].points >= paramw[:point_price]
$game_party.members[$gst_actor].points -= paramw[:point_price]
$game_party.members[$gst_actor].add_param(param_id,paramw[:point_value])
$game_party.members[$gst_actor].gain_exp(paramw[:inc_exp])
if Distribute_Config::Heal_Player
$game_party.members[$gst_actor].hp = $game_party.members[$gst_actor].mhp
$game_party.members[$gst_actor].mp = $game_party.members[$gst_actor].mmp
end
@param_window.activate
@param_window.select_last
else
RPG::SE.new(Distribute_Config::Wrong_Select,80).play
@param_window.activate
@param_window.select_last
end
end
refresh_all_window
end
#--------------------------------------------------------------------------
# * Ao cancelar na lista
#--------------------------------------------------------------------------
def on_cancel
return_scene
end
#--------------------------------------------------------------------------
# * Apagar todas as janelas
#--------------------------------------------------------------------------
def dispose_all_windows
@status_window.dispose
@points_window.dispose
@top_window.dispose
@param_window.dispose
@des_window.dispose
end
#--------------------------------------------------------------------------
# * Renovar todas janelas
#--------------------------------------------------------------------------
def refresh_all_window
@status_window.refresh
@points_window.refresh
@param_window.redraw_current_item
end
#--------------------------------------------------------------------------
# * Criação do fundo
#--------------------------------------------------------------------------
def create_background
@background_sprite = Sprite.new
@background_sprite.bitmap = SceneManager.background_bitmap
@background_sprite.color.set(16, 16, 16, 128)
end
#--------------------------------------------------------------------------
# * Apagar o fundo
#--------------------------------------------------------------------------
def dispose_background
@background_sprite.dispose
end
end
class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# * Fazer a lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_main_commands
if Distribute_Config::Put_On_Menu
add_dist_command
end
add_formation_command
add_original_commands
add_save_command
add_game_end_command
end
#--------------------------------------------------------------------------
# * Adicionar comando de distribuir pontos
#--------------------------------------------------------------------------
def add_dist_command
add_command(Distribute_Config::Menu_Vocab, :dist)
end
end
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# * Criar janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
if Distribute_Config::Put_On_Menu
@command_window.set_handler(:dist, method(:command_personal))
end
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Comandos individuais [Confirmação]
#--------------------------------------------------------------------------
def on_personal_ok
case @command_window.current_symbol
when :skill
SceneManager.call(Scene_Skill)
when :equip
SceneManager.call(Scene_Equip)
when :status
SceneManager.call(Scene_Status)
when :dist
SceneManager.call(Scene_Distribute)
$gst_actor = @status_window.index
end
end
end
#===============================================================================
# Fim do script
#===============================================================================
Verdade : ) troquei a ordem e funcionou...agora eu continuo usando os antigos ou troco pelos novos scripts?
Pode trocar pelos novos se quiser, pode facilitar e evitar erros!
Esses novos ficaram perfeitos : ) consertam ate o bug que dava no menu(quando o GST Distribute Points System estava configurado para aparecer no menu). E agora tanto faz a ordem que os scripts são colocados...tudo funciona perfeitamente.
Obrigado.
Então você gosta de trabalhar com janelas e o gráfico né?
Bom meu ultimo projeto foi um fracasso imenso pq n tinha uma historia bem feita... Então resolvi começar a juntar resouces pra um Fan-game de Kingdom-Hearts que estou planejando.. Nada muito sério nem começei um projeto ainda. Você conseguiria fazer uma lifebar com a mana e o HP do char? e o mais importante: No círculo do meio vai caber uma foto do seu personagem... vou colocar aqui algumas fotos me diga se é possível?
Imagem da lifebar original do KH2
(https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcQycl-VwVuWd1qsWpg0nsHCsv05nuwg5uj9kcB08SwCTZycWgze9Q)
Uma pixel art da barra pra ver se te serve de inspiração...
(http://img2.wikia.nocookie.net/__cb20121227225349/kingdomhearts/es/images/f/f2/Lifebar.png)
Lembrando esqueça a barra de "Drive" pq n vai rolar no meu game :derp:
Se for dificil colocar a mana e a vida certa funcionando e indicando qnt vc tem faz só a barra da vida que eu já fico feliz :XD:
Você poderia ter utilizado a ficha, mas como ficou bem explicado, eu faço! Vou tentar me aproximar ao máximo do seu pedido.
muito obrigado man! estarei ansioso. Gosto muito dos seus scripts tipo os das luzinhas (não lembro o nome mas uso nas florestas do meu game pra dar um efeito real)
[box2 class=titlebg title=Pedido]
Membro: Miguel884
Pedido: Venho pedir um script no qual os eventos possam ocupar mais espaço no mapa, tipo um char que tenho é maior que o padrão do ace, ele ocupa 3 tiles horizontais e 3 verticais (no jogo) assim:
▨▨▨
▨▨▨
▨▨▨Cada quadrinho é um tile, o quadrinho vermelho é onde criei o evento no mapa, os quadrados ao todo são os tiles no qual o char ocupa no mapa. Normalmente o ator precisa chegar no tile criado para aciona-lo, queria um script que pudesse acionar esse evento (que ocupa vários tiles) nesses outros tiles sem ter que copiar o mesmo evento para esses outros tiles.
Imagens: Nenhuma.
Algo em que se basear: Tem esse script do MOG que é um sensor para eventos. Ele faz com que o evento seja ativo quando o herói estiver X tiles perto dele só que em uma outra página do evento.
Script
#==============================================================================
# +++ MOG - Event Sensor Range (v1.0) +++
#==============================================================================
# By Moghunter
# http://www.atelier-rgss.com
#==============================================================================
# Permite que o evento tenha dois comportamentos, de curta distância e de
# longa distância.
#===============================================================================
# - Utilização
# Crie uma página com a condição de ativação Self Switch D, está página será
# usada quando o player estiver perto do evento.
# Defina a area do sensor do evento colocando este nome no evento.
#
# <SensorX>
#
# X = Area do Sensor
#
#===============================================================================
module MOG_EVENT_SENSOR
#Definição da letra da Self Switch que ativará a página de curta distância.
SENSOR_SELF_SWITCH = "D"
end
#===============================================================================
# ■ GAME EVENT
#===============================================================================
class Game_Event < Game_Character
attr_reader :sensor_range
#--------------------------------------------------------------------------
# ● Initialize
#--------------------------------------------------------------------------
alias mog_event_sensor_initialize initialize
def initialize(map_id, event)
mog_event_sensor_initialize(map_id, event)
setup_event_sensor
end
#--------------------------------------------------------------------------
# ● Setup Event Sensor
#--------------------------------------------------------------------------
def setup_event_sensor
@sensor_range = @event.name =~ /<Sensor(\d+)>/ ? $1.to_i : 0
end
#--------------------------------------------------------------------------
# ● Update
#--------------------------------------------------------------------------
alias mog_event_sensor_update update
def update
mog_event_sensor_update
update_event_sensor
end
#--------------------------------------------------------------------------
# ● Update Sensor
#--------------------------------------------------------------------------
def update_event_sensor
return if @sensor_range == 0
distance = ($game_player.x - self.x).abs + ($game_player.y - self.y).abs
enable = (distance <= @sensor_range)
key = [$game_map.map_id, self.id, MOG_EVENT_SENSOR::SENSOR_SELF_SWITCH]
last_enable = $game_self_switches[key]
execute_sensor_effect(enable,key) if enable != last_enable
end
#--------------------------------------------------------------------------
# ● Execute_Sensor Effect
#--------------------------------------------------------------------------
def execute_sensor_effect(enable,key)
@pattern = 0 ; @pattern_count = 0
$game_self_switches[key] = enable ; self.refresh
end
end
$mog_rgss3_event_sensor = true
Talvez Média ou Dificil, não entendo RGSS(3) por isso não tenho como afirmar.
Tamanho da tela: 640x480 (Padrão XP só que no Ace)
[/box2]
Bem é isso, desculpe lhe abusar por mais um script e talz. O script do mog tem um sensor do tipo '360' ele não da o resultado que eu quero já que ele é feito para chars padrões do ACe, ou seja, do tamanho normal. Quero um script no qual eu possa colocar o numero de tiles a mais nos lados e para cima (X e Y) e ai o evento substituirá esses tiles como se houvesse outros eventos iguais a ele nesses outros tiles, para isso quero poder colocar no evento "grande" algo parecido com isso:
X=3
Y=1Porquê? O evento quando ultrapassa os padrões do Ace o char fica centralizado no tile, assim como no exemplo.
▨▨▨
▨▨▨
▨▨▨Coloquei lá
Y=1 pois tem um tile a mais em cada lado, e
X=3 pois o char ocupa mais três tiles pra cima. Não sei se é X e Y eu sempre me confundo :XD: . Fui explicativo?
Membro: Miguel8844
Pedido: Bom eu estava querendo fazer um jogo, sobre Star Wars e eu queria um ABS, que fosse possível que usasse para uns personagens o sabre de luz e para outros a arma de laser.
Imagens: Nenhuma.
Algo em que se basear: http://centrorpg.com/index.php?topic=870.0
Complexidade da configuração: Eu prefiro um sistema bastante configurável,para se o script tiver alguma falha eu mesmo poder arrumar.
Quero pedir a todos desculpas pela demora nos scripts e pela falta do meu esclarecimento diante das circunstâncias...
É porque devem saber que eu estudo, enfim, estou em provas e fiquei com o tempo curto para tudo, também estou com muitos trabalhos para fazer. Então peço que entendam a minha demora, não vou deixar de fazer o pedido do Akkain!
O ArrowPotter me informou ter encontrado o script que precisava, e Destructor, desculpe, mas sistemas de batalhas sã meio complicados de fazer ainda mais no momento, esqueci de colocar que não faria sistemas de batalhas, sorry /:!
Membro: Miguel8884
Pedido: Eu uso o Pixel Moviment que vem com 8 direções eu queria um script que quando o personagem ir andar nas 8 direções tivesse um gráfico com ele nas diagonais.
Imagens: ñ
Algo em que se basear: nada
Complexidade da configuração: pouca configuração
Tamanho da tela: 544 x 416
Citação de: KertonGames online 22/09/2014 às 12:57
Membro: Miguel8884
Pedido: Eu uso o Pixel Moviment que vem com 8 direções eu queria um script que quando o personagem ir andar nas 8 direções tivesse um gráfico com ele nas diagonais.
Imagens: ñ
Algo em que se basear: nada
Complexidade da configuração: pouca configuração
Tamanho da tela: 544 x 416
Se não me engano já existe um script que faz isso, só uma pesquisada e você encontra facilmente. Além disso, você teria que deixar o script que usa pois caso o Miguel poderia fazer algum script que não se adequasse ao seu Pixel Moviment.
Oi, você ainda está livre para fazer scripts?
Vou dar meu aviso, eu fiquei um bom tempo sem internet, por isso fiquei meio inativo aqui no fórum, as hora que entrei, foram devido ao meu celular! Eu estou de volta mas peço que não façam pedidos por enquanto até eu me acertar :ok:
E ai Miguel8884, poderia atualizar o script
para uma tela 640x480 eu risquei porque eu resolvi isso era só ajustar a tela do meu monitor e adicionar um detalhe, quando eu adiciono algum script que tenha opção de mostrar no menu,a "coluna de opções" desce de maneira bugada, poderia fazer ela subir ao invés de descer.
vlw ai ate.
Spoiler
#===============================================================================
# Kinsoyo RGSS3 Factory - Scene_Menu edit
# By: Miguel8884
#
# Não foi 100% por alguns erros que encontrei no caminho, mas tentei me
# aproximar ao máximo ao pedido!
#===============================================================================
class Scene_ItemBase < Scene_MenuBase
#--------------------------------------------------------------------------
# * Exibição da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def show_sub_window(window)
width_remain = Graphics.width - window.width
window.x = 0
window.y = 0
window.show.activate
end
#--------------------------------------------------------------------------
# * Ocultação da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def hide_sub_window(window)
window.hide.deactivate
activate_item_window
end
end
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
#--------------------------------------------------------------------------
def initialize(x,y)
super(x, window_y, window_width, window_height)
@pending_index = -1
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da altura da janela
#--------------------------------------------------------------------------
def window_height
98 + 24
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
98
end
end
class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
#--------------------------------------------------------------------------
def initialize(x)
super(x, window_y)
select_last
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
if Distribute_Config::Put_On_Menu
Graphics.height-(98+24)-fitting_height(8)
else
Graphics.height-(98+24)-fitting_height(7)
end
end
end
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_command_window
create_status_window
create_gold_window
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_MenuStatus.new(0,0)
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
if Distribute_Config::Put_On_Menu
@command_window.set_handler(:dist, method(:command_personal))
end
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de dinheiro
#--------------------------------------------------------------------------
def create_gold_window
@gold_window = Window_Gold.new
@gold_window.x = 160
@gold_window.y = Graphics.height - @gold_window.height - @status_window.height
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Criação da janela de categorias
#--------------------------------------------------------------------------
def create_category_window
@category_window = Window_ItemCategoryEdit.new
@category_window.viewport = @viewport
@category_window.help_window = @help_window
@category_window.y = Graphics.height - @help_window.height - @category_window.height
@category_window.set_handler(:ok, method(:on_category_ok))
@category_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de ajuda.
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_HelpItem.new
@help_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
@item_window = Window_ItemList.new(160, 0, Graphics.width-160, Graphics.height-96*2)
@item_window.y = Graphics.height - @help_window.height - @item_window.height
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
end
class Window_ItemCategoryEdit < Window_Command
#--------------------------------------------------------------------------
# * Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :item_window
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def visible_line_number
return 4
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@item_window.category = current_symbol if @item_window
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::item, :item)
add_command(Vocab::weapon, :weapon)
add_command(Vocab::armor, :armor)
add_command(Vocab::key_item, :key_item)
end
#--------------------------------------------------------------------------
# * Definição da janela de itens
# item_window : janela de itens
#--------------------------------------------------------------------------
def item_window=(item_window)
@item_window = item_window
update
end
end
class Window_HelpItem < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# line_number : número de linhas
#--------------------------------------------------------------------------
def initialize(line_number = 2)
super(0, window_y, Graphics.width, fitting_height(line_number))
end
#--------------------------------------------------------------------------
# * Configuração de texto
# text : texto
#--------------------------------------------------------------------------
def set_text(text)
if text != @text
@text = text
refresh
end
end
def window_y
return Graphics.height-fitting_height(2)
end
#--------------------------------------------------------------------------
# * Limpeza
#--------------------------------------------------------------------------
def clear
set_text("")
end
#--------------------------------------------------------------------------
# * Definição de item
# item : habilidades, itens, etc.
#--------------------------------------------------------------------------
def set_item(item)
set_text(item ? item.description : "")
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
contents.clear
draw_text_ex(4, 0, @text)
end
end
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Scene_Skill < Scene_ItemBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_help_window
create_status_window
create_command_window
create_item_window
@help_window.y = Graphics.height - @status_window.height - @item_window.height - @help_window.height
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_SkillStatus.new(0, Graphics.height-(98+22))
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wx = 160
ww = Graphics.width - 160
@item_window = Window_SkillList.new(wx, 0, ww, 4*24+24)
@item_window.y = Graphics.height - @status_window.height - @item_window.height
@item_window.actor = @actor
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@command_window.skill_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_SkillCommand.new(0, 0)
@command_window.y = Graphics.height - @status_window.height - (4*24+24)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.actor = @actor
@command_window.set_handler(:skill, method(:command_skill))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
end
class Scene_Equip < Scene_MenuBase
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_EquipStatus.new(0, 0)
@status_window.x = Graphics.width-@status_window.width
@status_window.y = Graphics.height-@status_window.height
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de slots
#--------------------------------------------------------------------------
def create_slot_window
wy = @command_window.y + @command_window.height
ww = Graphics.width - @status_window.width
@slot_window = Window_EquipSlot.new(0, wy, ww)
@slot_window.viewport = @viewport
@slot_window.help_window = @help_window
@slot_window.status_window = @status_window
@slot_window.actor = @actor
@slot_window.set_handler(:ok, method(:on_slot_ok))
@slot_window.set_handler(:cancel, method(:on_slot_cancel))
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
wy = @help_window.height
@command_window = Window_EquipCommandItem.new(0, wy)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.set_handler(:equip, method(:command_equip))
@command_window.set_handler(:optimize, method(:command_optimize))
@command_window.set_handler(:clear, method(:command_clear))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
#--------------------------------------------------------------------------
# * Criação da janela de item
#--------------------------------------------------------------------------
def create_item_window
wx = 0
wy = @slot_window.y + @slot_window.height
ww = Graphics.width-@status_window.width
wh = Graphics.height - wy
@item_window = Window_EquipItem.new(wx, wy, ww, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.status_window = @status_window
@item_window.actor = @actor
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@slot_window.item_window = @item_window
end
end
class Window_EquipCommandItem < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::equip2, :equip)
add_command(Vocab::optimize, :optimize)
add_command(Vocab::clear, :clear)
end
end
# Fim do script #
Coloque uma screen do que acntece, se não fica dificil eu concertar
Olha ela aparece por tráz da outra janela.
(http://i.imgur.com/IUuBHFX.png)
Ah sim, entendi, vou editar hora que tiver um pouco mais de tempo, agora estou meio ocupado! Mas é bem rápido!
:*-*: legal fico aguardando a atualização : )
Acho que isso resolve!
#===============================================================================
# Kinsoyo RGSS3 Factory - Scene_Menu edit
# By: Miguel8884
#
# Não foi 100% por alguns erros que encontrei no caminho, mas tentei me
# aproximar ao máximo ao pedido!
#===============================================================================
class Scene_ItemBase < Scene_MenuBase
#--------------------------------------------------------------------------
# * Exibição da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def show_sub_window(window)
width_remain = Graphics.width - window.width
window.x = 0
window.y = 0
window.show.activate
end
#--------------------------------------------------------------------------
# * Ocultação da sub-janela
# window : sub-janela
#--------------------------------------------------------------------------
def hide_sub_window(window)
window.hide.deactivate
activate_item_window
end
end
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
#--------------------------------------------------------------------------
def initialize(x,y)
super(x, window_y, window_width, window_height)
@pending_index = -1
refresh
end
#--------------------------------------------------------------------------
# * Aquisição da altura da janela
#--------------------------------------------------------------------------
def window_height
98 + 24
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
Graphics.height-(98+24)
end
#--------------------------------------------------------------------------
# * Aquisição de altura do item
#--------------------------------------------------------------------------
def item_height
98
end
end
class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
#--------------------------------------------------------------------------
def initialize(x)
super(x, window_y)
select_last
end
#--------------------------------------------------------------------------
# * Aquisição da coordenada Y
#--------------------------------------------------------------------------
def window_y
return 0
end
end
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_status_window
create_command_window
create_gold_window
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_MenuStatus.new(0,0)
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_MenuCommand.new(0)
@command_window.y = Graphics.height - @command_window.height - @status_window.height
@command_window.set_handler(:item, method(:command_item))
@command_window.set_handler(:skill, method(:command_personal))
@command_window.set_handler(:equip, method(:command_personal))
if Distribute_Config::Put_On_Menu
@command_window.set_handler(:dist, method(:command_personal))
end
@command_window.set_handler(:status, method(:command_personal))
@command_window.set_handler(:formation, method(:command_formation))
@command_window.set_handler(:save, method(:command_save))
@command_window.set_handler(:game_end, method(:command_game_end))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de dinheiro
#--------------------------------------------------------------------------
def create_gold_window
@gold_window = Window_Gold.new
@gold_window.x = 160
@gold_window.y = Graphics.height - @gold_window.height - @status_window.height
end
end
class Scene_Item < Scene_ItemBase
#--------------------------------------------------------------------------
# * Criação da janela de categorias
#--------------------------------------------------------------------------
def create_category_window
@category_window = Window_ItemCategoryEdit.new
@category_window.viewport = @viewport
@category_window.help_window = @help_window
@category_window.y = Graphics.height - @help_window.height - @category_window.height
@category_window.set_handler(:ok, method(:on_category_ok))
@category_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# * Criação da janela de ajuda.
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_HelpItem.new
@help_window.viewport = @viewport
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
@item_window = Window_ItemList.new(160, 0, Graphics.width-160, Graphics.height-96*2)
@item_window.y = Graphics.height - @help_window.height - @item_window.height
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@category_window.item_window = @item_window
end
end
class Window_ItemCategoryEdit < Window_Command
#--------------------------------------------------------------------------
# * Variáveis públicas
#--------------------------------------------------------------------------
attr_reader :item_window
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def visible_line_number
return 4
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
super
@item_window.category = current_symbol if @item_window
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::item, :item)
add_command(Vocab::weapon, :weapon)
add_command(Vocab::armor, :armor)
add_command(Vocab::key_item, :key_item)
end
#--------------------------------------------------------------------------
# * Definição da janela de itens
# item_window : janela de itens
#--------------------------------------------------------------------------
def item_window=(item_window)
@item_window = item_window
update
end
end
class Window_HelpItem < Window_Base
#--------------------------------------------------------------------------
# * Inicialização do objeto
# line_number : número de linhas
#--------------------------------------------------------------------------
def initialize(line_number = 2)
super(0, window_y, Graphics.width, fitting_height(line_number))
end
#--------------------------------------------------------------------------
# * Configuração de texto
# text : texto
#--------------------------------------------------------------------------
def set_text(text)
if text != @text
@text = text
refresh
end
end
def window_y
return Graphics.height-fitting_height(2)
end
#--------------------------------------------------------------------------
# * Limpeza
#--------------------------------------------------------------------------
def clear
set_text("")
end
#--------------------------------------------------------------------------
# * Definição de item
# item : habilidades, itens, etc.
#--------------------------------------------------------------------------
def set_item(item)
set_text(item ? item.description : "")
end
#--------------------------------------------------------------------------
# * Renovação
#--------------------------------------------------------------------------
def refresh
contents.clear
draw_text_ex(4, 0, @text)
end
end
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# * Aquisição do número de colunas
#--------------------------------------------------------------------------
def col_max
return 1
end
end
class Scene_Skill < Scene_ItemBase
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
super
create_help_window
create_status_window
create_command_window
create_item_window
@help_window.y = Graphics.height - @status_window.height - @item_window.height - @help_window.height
end
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_SkillStatus.new(0, Graphics.height-(98+22))
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de itens
#--------------------------------------------------------------------------
def create_item_window
wx = 160
ww = Graphics.width - 160
@item_window = Window_SkillList.new(wx, 0, ww, 4*24+24)
@item_window.y = Graphics.height - @status_window.height - @item_window.height
@item_window.actor = @actor
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@command_window.skill_window = @item_window
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_SkillCommand.new(0, 0)
@command_window.y = Graphics.height - @status_window.height - (4*24+24)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.actor = @actor
@command_window.set_handler(:skill, method(:command_skill))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
end
class Scene_Equip < Scene_MenuBase
#--------------------------------------------------------------------------
# * Criação da janela de atributos
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_EquipStatus.new(0, 0)
@status_window.x = Graphics.width-@status_window.width
@status_window.y = Graphics.height-@status_window.height
@status_window.viewport = @viewport
@status_window.actor = @actor
end
#--------------------------------------------------------------------------
# * Criação da janela de slots
#--------------------------------------------------------------------------
def create_slot_window
wy = @command_window.y + @command_window.height
ww = Graphics.width - @status_window.width
@slot_window = Window_EquipSlot.new(0, wy, ww)
@slot_window.viewport = @viewport
@slot_window.help_window = @help_window
@slot_window.status_window = @status_window
@slot_window.actor = @actor
@slot_window.set_handler(:ok, method(:on_slot_ok))
@slot_window.set_handler(:cancel, method(:on_slot_cancel))
end
#--------------------------------------------------------------------------
# * Criação da janela de comando
#--------------------------------------------------------------------------
def create_command_window
wy = @help_window.height
@command_window = Window_EquipCommandItem.new(0, wy)
@command_window.viewport = @viewport
@command_window.help_window = @help_window
@command_window.set_handler(:equip, method(:command_equip))
@command_window.set_handler(:optimize, method(:command_optimize))
@command_window.set_handler(:clear, method(:command_clear))
@command_window.set_handler(:cancel, method(:return_scene))
@command_window.set_handler(:pagedown, method(:next_actor))
@command_window.set_handler(:pageup, method(:prev_actor))
end
#--------------------------------------------------------------------------
# * Criação da janela de item
#--------------------------------------------------------------------------
def create_item_window
wx = 0
wy = @slot_window.y + @slot_window.height
ww = Graphics.width-@status_window.width
wh = Graphics.height - wy
@item_window = Window_EquipItem.new(wx, wy, ww, wh)
@item_window.viewport = @viewport
@item_window.help_window = @help_window
@item_window.status_window = @status_window
@item_window.actor = @actor
@item_window.set_handler(:ok, method(:on_item_ok))
@item_window.set_handler(:cancel, method(:on_item_cancel))
@slot_window.item_window = @item_window
end
end
class Window_EquipCommandItem < Window_Command
#--------------------------------------------------------------------------
# * Inicialização do objeto
# x : coordenada X
# y : coordenada Y
# width : largura
#--------------------------------------------------------------------------
def initialize(x, y)
super(x, y)
end
#--------------------------------------------------------------------------
# * Aquisição da largura da janela
#--------------------------------------------------------------------------
def window_width
return 160
end
#--------------------------------------------------------------------------
# * Criação da lista de comandos
#--------------------------------------------------------------------------
def make_command_list
add_command(Vocab::equip2, :equip)
add_command(Vocab::optimize, :optimize)
add_command(Vocab::clear, :clear)
end
end
# Fim do script #
Legal ! está perfeito!!! :*-*:
+golds
Muito obrigado.
ate +
OBS: Não sei se isso é muito complexo
Membro: Miguel 8884
Pedido: Personagens que tem habilidades e etc... igual, Exemplo: Fulano equipou uma arma ciclano tambem vai estar com a arma equipada, Ciclano subiu de nivel e aprendeu habilidade, Fulano tambem vai subir e aprender habilidade(compartilham a mesma vida tmabem) (os personagens que vão ter esse esquema pode deixar que eu coloco depois no script :ok:)
Imagens: nada
Algo em que se basear: nada
Complexidade da configuração: (OBS no inico da ficha) e a parte de colocar os personagens que eu quero que tenham o esquema pode deixar que eu faço
Tamanho da tela: Vx ace
Membro: miguel8884
Pedido: Uma HUD para Boss. Ela é ligada por uma switch e mostra o valor de uma variável . Faça ela bem extensa ocupando toda a área inferior da tela. (Se precisar de um valor pré definido para a variável, pode ser 1000). Se puder ter a cor customizável seria bom, com uma função de mudar a cor da HUD por "chamar Script". As imagens usadas ficaram numa pasta em Jogo/Graphics/Special
Imagens: Use a HUD Base e Bar para ficar com esse design Pasta Special (https://dl.dropboxusercontent.com/u/32809063/Special.rar)
Algo em que se basear: Não acho que tem
Complexidade da configuração: Pouca eu acho... está explicado o que deverá ser customizável e tal
Tamanho da tela: Normal do Ace
Hum deixa-me ver se entendi!
A hud deverá aparecer aonde? No mapa?
Se eu for usar imagens não terá como mudar a cor.
Citação de: miguel8884 online 15/12/2014 às 19:14
Hum deixa-me ver se entendi!
A hud deverá aparecer aonde? No mapa?
Se eu for usar imagens não terá como mudar a cor.
Aham, é pra aparecer no mapa.
Se puder usar só a base então... o rect pode ser do rpg maker mesmo
Okay, pedido aceito, acho que até quinta eu entrego!
Membro: Equinho
Pedido: Quero um Script que o Heroi se tiver possuindo um Equipamento do Tipo "Arma de Fogo" ele so pode atirar se tiver o item "Munição" :D e também uma pequena HUD Mostrando o Tanto de Balas que o Jogador Possui (A HUD Pode Ser Feita por Voces Mesmo, Qualquer coisa eu a edito) :D bem é isso ah outra coisa o jogador se tiver a arma de fogo ele so pode atacar e usar habilidades se tiver o item munição ou seja ele não pode usar nem ataque normal :D
Imagens: Não é necessário
Complexidade da configuração: Quero que o Script fique Ativo Toda Hora!
Deixa ver se eu entendi... Seria na batalha normal do rpg maker né?
Isso Mesmo! Quero ele pra batalha normal e nao pra sistemas tipo ABS, XAS etc etc :)
Okay pedido aceito, talvez eu entregue até sexta!
Tudo Bem :ok:
[box2 class=titlebg title=Pedido LipeJamesPotter]Membro: O único e inconfundível Miguel884
Pedido: Script que desse valores diferentes a variáveis, tipo, tenho 14 variáveis diferentes e cada uma delas tem que receber um valor de 1 a 34 e nenhuma deve ter o valor igual. Fiz por eventos mas paralisa o jogo não sei porquê... quero poder adicionar quantas variáveis eu quiser e que eu possa definir o valor "De" "até" como por exemplo:
Defina aqui o ID das variáveis que receberão o valor aleatório: 001, 002, 003, 004, 005, 006
Defina aqui o valor aleatório que elas receberão: de 01 até 14
Queria que você dividivel, ou seja, que eu possa no script adicionar outro comando para outras variaveis ex:
Defina aqui o ID das variáveis que receberão o valor aleatório: 001, 002, 003, 004, 005, 006
Defina aqui o valor aleatório que elas receberão: de 01 até 14
=======================================================================
Defina aqui o ID das variáveis que receberão o valor aleatório: 014, 015, 016, 017, 018
Defina aqui o valor aleatório que elas receberão: de 01 até 20
Imagens: nenhuma.
Algo em que se basear: Nada.
Complexidade da configuração: Fácil
Tamanho da tela: 640x480[/box2]
Citação de: ArrowPotter online 17/12/2014 às 21:34
[box2 class=titlebg title=Pedido LipeJamesPotter]Membro: O único e inconfundível Miguel884
Pedido: Script que desse valores diferentes a variáveis, tipo, tenho 14 variáveis diferentes e cada uma delas tem que receber um valor de 1 a 34 e nenhuma deve ter o valor igual. Fiz por eventos mas paralisa o jogo não sei porquê... quero poder adicionar quantas variáveis eu quiser e que eu possa definir o valor "De" "até" como por exemplo:
Defina aqui o ID das variáveis que receberão o valor aleatório: 001, 002, 003, 004, 005, 006
Defina aqui o valor aleatório que elas receberão: de 01 até 14
Queria que você dividivel, ou seja, que eu possa no script adicionar outro comando para outras variaveis ex:
Defina aqui o ID das variáveis que receberão o valor aleatório: 001, 002, 003, 004, 005, 006
Defina aqui o valor aleatório que elas receberão: de 01 até 14
=======================================================================
Defina aqui o ID das variáveis que receberão o valor aleatório: 014, 015, 016, 017, 018
Defina aqui o valor aleatório que elas receberão: de 01 até 20
Imagens: nenhuma.
Algo em que se basear: Nada.
Complexidade da configuração: Fácil
Tamanho da tela: 640x480[/box2]
Como já estou com dois pedidos, ainda não vou declarar como aceito, após os dois serem finalizados, eu já coloco o seu na lista.
Agora sobre o script, talvez eu possa demorar um pouco pois essa de não poderem ser valores iguais vai quebrar minha cabeça, mas eu tento fazer!
Nick Rock seu pedido está pronto, eu tentei fazer ao máximo parecido do que você pediu, caso alguma coisa esteja errada você me avisa que eu mude.
Apenas colocar e configurar:
#===============================================================================
# Kinsoyo RGSS3 Factory - Pedido de Nick Rock
#-------------------------------------------------------------------------------
# Boss Hud On Map
# Por: Miguel8884
#-------------------------------------------------------------------------------
# Intruções:
# Leia a seguir as instruções para usar corretamente o script.
#
# Ao ativar a switch a hud irá aparecer suavemente na mesma hora.
#
# Para mudar a cor da hud use no chamar script o seguinte comando:
# change_bar_color(r,g,b,opacity)
# Sendo "r" sem aspas o vermelho em números
# Sendo "g" sem aspas o verde em números
# Sendo "b" sem aspas o azul em números
# Sendo "opacity" sem aspas a opacidade da cor em números
#-------------------------------------------------------------------------------
# Boa sorte com o uso do script! (:
#===============================================================================
module GST
module Factory
module Nick_Rock
#----------------------------------------------------------------------
# Configurações
#----------------------------------------------------------------------
# Id da variável que guarda o máximo que a barra da hud pode atingir
Max_Bar_Var = 1
# Id da variável que guarda o valor atual
Actual_Bar_Var = 2
# Switch que ativa a hud
Switch_Bar = 1
# Nome da base na pasta pictures
Base_Name = "HUDBaseBoss"
#----------------------------------------------------------------------
# Fim das configurações
#----------------------------------------------------------------------
end
end
end
# Aqui começa o script - Não mexa #
class Game_Interpreter
#--------------------------------------------------------------------------
# * Modificar cor da hud
#--------------------------------------------------------------------------
def change_bar_color(r,g,b,o = 255)
$gst_boss_bar_color = [r,g,b,o]
end
end
class Boss_FAC_Hud
#--------------------------------------------------------------------------
# * Incluir module de configuração
#--------------------------------------------------------------------------
include GST::Factory::Nick_Rock
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
create_help_vars
create_base
end
#--------------------------------------------------------------------------
# * Criação das variáveis base
#--------------------------------------------------------------------------
def create_base
if $gst_boss_bar_color.nil?
$gst_boss_bar_color = [50,50,50,255]
end
if $game_variables[Max_Bar_Var] == 0
$game_variables[Max_Bar_Var] = 1
end
@base = Sprite.new
@base.bitmap = Bitmap.new("Graphics/Pictures/#{Base_Name}")
@base.x = 21
@base.y = 416-17-21
@bars = [Sprite.new,Sprite.new]
@bars.each do |b|
b.bitmap = Bitmap.new(499,7)
end
if $game_switches[Switch_Bar] == false
@base.opacity = 0
@bars.each do |bar|
bar.opacity = 0
end
end
fill_bars
end
#--------------------------------------------------------------------------
# * Criação das varíaveis de auxílio
#--------------------------------------------------------------------------
def create_help_vars
@var1 = $game_variables[Actual_Bar_Var]
@var2 = $game_variables[Max_Bar_Var]
@color = $gst_boss_bar_color
end
#--------------------------------------------------------------------------
# * Atualização do objeto
#--------------------------------------------------------------------------
def update
if $game_switches[Switch_Bar] == false
@base.opacity -= 5 if @base.opacity > 0
@bars.each do |bar|
bar.opacity -= 5 if bar.opacity > 0
end
else
@base.opacity += 5 if @base.opacity < 255
@bars.each do |bar|
bar.opacity += 5 if bar.opacity < 255
end
fill_bars if necessary?
end
end
#--------------------------------------------------------------------------
# * Apagar imagens do objeto
#--------------------------------------------------------------------------
def dispose
@base.bitmap.dispose
@base.dispose
@bars.each do |bar|
bar.bitmap.dispose
bar.dispose
end
end
#--------------------------------------------------------------------------
# * Preencher as barras da hud
#--------------------------------------------------------------------------
def fill_bars
rate = ($game_variables[Actual_Bar_Var].to_f/$game_variables[Max_Bar_Var].to_f*100.0).to_i
@bars.each do |bar|
size = (bar.bitmap.width.to_f*rate.to_f/100.0).to_i
bar.bitmap.clear
@bars.index(bar) == 0 ? bar.bitmap.fill_rect(0,0,size,7,color_hud1) : bar.bitmap.fill_rect(0,0,size,7,color_hud2)
bar.x = @base.x + 1
@bars.index(bar) == 0 ? bar.y = @base.y + 7 : bar.y = @base.y + 1
end
create_help_vars
end
#--------------------------------------------------------------------------
# * Verifica se a hud precisa atualizar
#--------------------------------------------------------------------------
def necessary?
return true if @var1 != $game_variables[Actual_Bar_Var]
return true if @var2 != $game_variables[Max_Bar_Var]
return true if @color != $gst_boss_bar_color
end
#--------------------------------------------------------------------------
# * Cor primária da hud
#--------------------------------------------------------------------------
def color_hud1
Color.new($gst_boss_bar_color[0],$gst_boss_bar_color[1],$gst_boss_bar_color[2],$gst_boss_bar_color[3])
end
#--------------------------------------------------------------------------
# * Cor secundária da hud
#--------------------------------------------------------------------------
def color_hud2
Color.new($gst_boss_bar_color[0]+25,$gst_boss_bar_color[1]+25,$gst_boss_bar_color[2]+25,$gst_boss_bar_color[3])
end
end
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# * Alias
#--------------------------------------------------------------------------
alias :gst_fact_nr_9819_start :start
alias :gst_fact_nr_7821_update :update
alias :gst_fact_nr_1723_terminate :terminate
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
create_hud
gst_fact_nr_9819_start
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
@boss_hud.update
gst_fact_nr_7821_update
end
#--------------------------------------------------------------------------
# * Finalização do processo
#--------------------------------------------------------------------------
def terminate
@boss_hud.dispose
gst_fact_nr_1723_terminate
end
#--------------------------------------------------------------------------
# * Criar a hud
#--------------------------------------------------------------------------
def create_hud
@boss_hud = Boss_FAC_Hud.new
end
end
# Fim do script #
Citação de: miguel8884 online 18/12/2014 às 16:38
Nick Rock seu pedido está pronto, eu tentei fazer ao máximo parecido do que você pediu, caso alguma coisa esteja errada você me avisa que eu mude.
Ficou muito bom, obrigado !
Mas você poderia me passar a imagem que você usou para a Base da HUD? Porque com a imagem que eu uso, a base fica menor que a barra de HP do Boss
E, se não for complicar muito, poderia colocar na HUD a quantidade de HP atual do Boss?
Opa desculpa, eu acabei me esquecendo de passar a imagem :facepalm:!
(http://i.imgur.com/yaEd83v.png)
O script eu coloco a quantidade, não cheguei a colocar por que não pediu, eu vou fazer depois dou um edit, não sei se vai ser agora por que hoje ta bem corrido para mim, mas quando possível!
@edit:
Aqui o script com a quantidade!
#===============================================================================
# Kinsoyo RGSS3 Factory - Pedido de Nick Rock
#-------------------------------------------------------------------------------
# Boss Hud On Map
# Por: Miguel8884
#-------------------------------------------------------------------------------
# Intruções:
# Leia a seguir as instruções para usar corretamente o script.
#
# Ao ativar a switch a hud irá aparecer suavemente na mesma hora.
#
# Para mudar a cor da hud use no chamar script o seguinte comando:
# change_bar_color(r,g,b,opacity)
# Sendo "r" sem aspas o vermelho em números
# Sendo "g" sem aspas o verde em números
# Sendo "b" sem aspas o azul em números
# Sendo "opacity" sem aspas a opacidade da cor em números
#-------------------------------------------------------------------------------
# Boa sorte com o uso do script! (:
#===============================================================================
module GST
module Factory
module Nick_Rock
#----------------------------------------------------------------------
# Configurações
#----------------------------------------------------------------------
# Id da variável que guarda o máximo que a barra da hud pode atingir
Max_Bar_Var = 1
# Id da variável que guarda o valor atual
Actual_Bar_Var = 2
# Switch que ativa a hud
Switch_Bar = 1
# Nome da base na pasta pictures
Base_Name = "HUDBaseBoss"
#----------------------------------------------------------------------
# Fim das configurações
#----------------------------------------------------------------------
end
end
end
# Aqui começa o script - Não mexa #
class Game_Interpreter
#--------------------------------------------------------------------------
# * Modificar cor da hud
#--------------------------------------------------------------------------
def change_bar_color(r,g,b,o = 255)
$gst_boss_bar_color = [r,g,b,o]
end
end
class Boss_FAC_Hud
#--------------------------------------------------------------------------
# * Incluir module de configuração
#--------------------------------------------------------------------------
include GST::Factory::Nick_Rock
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
create_help_vars
create_base
end
#--------------------------------------------------------------------------
# * Criação das variáveis base
#--------------------------------------------------------------------------
def create_base
if $gst_boss_bar_color.nil?
$gst_boss_bar_color = [50,50,50,255]
end
if $game_variables[Max_Bar_Var] == 0
$game_variables[Max_Bar_Var] = 1
end
@base = Sprite.new
@base.bitmap = Bitmap.new("Graphics/Pictures/#{Base_Name}")
@base.x = 21
@base.y = 416-17-21
@bars = [Sprite.new,Sprite.new]
@value_amount = Sprite.new
@value_amount.bitmap = Bitmap.new(501,24)
@value_amount.x = 21
@value_amount.y = 416-17-24
@value_amount.z = 3
@bars.each do |b|
b.bitmap = Bitmap.new(499,7)
end
if $game_switches[Switch_Bar] == false
@base.opacity = 0
@bars.each do |bar|
bar.opacity = 0
end
@value_amount.opacity = 0
end
fill_bars
end
#--------------------------------------------------------------------------
# * Criação das varíaveis de auxílio
#--------------------------------------------------------------------------
def create_help_vars
@var1 = $game_variables[Actual_Bar_Var]
@var2 = $game_variables[Max_Bar_Var]
@color = $gst_boss_bar_color
end
#--------------------------------------------------------------------------
# * Atualização do objeto
#--------------------------------------------------------------------------
def update
if $game_switches[Switch_Bar] == false
@base.opacity -= 5 if @base.opacity > 0
@bars.each do |bar|
bar.opacity -= 5 if bar.opacity > 0
end
@value_amount.opacity -= 5 if @value_amount.opacity > 0
else
@base.opacity += 5 if @base.opacity < 255
@bars.each do |bar|
bar.opacity += 5 if bar.opacity < 255
end
@value_amount.opacity += 5 if @value_amount.opacity < 255
fill_bars if necessary?
end
end
#--------------------------------------------------------------------------
# * Apagar imagens do objeto
#--------------------------------------------------------------------------
def dispose
@base.bitmap.dispose
@base.dispose
@bars.each do |bar|
bar.bitmap.dispose
bar.dispose
end
@value_amount.dispose
end
#--------------------------------------------------------------------------
# * Preencher as barras da hud
#--------------------------------------------------------------------------
def fill_bars
rate = ($game_variables[Actual_Bar_Var].to_f/$game_variables[Max_Bar_Var].to_f*100.0).to_i
@bars.each do |bar|
size = (bar.bitmap.width.to_f*rate.to_f/100.0).to_i
bar.bitmap.clear
@bars.index(bar) == 0 ? bar.bitmap.fill_rect(0,0,size,7,color_hud1) : bar.bitmap.fill_rect(0,0,size,7,color_hud2)
bar.x = @base.x + 1
@bars.index(bar) == 0 ? bar.y = @base.y + 7 : bar.y = @base.y + 1
end
create_help_vars
@value_amount.bitmap.clear
@value_amount.bitmap.draw_text(0,0,501,24,"#{@var1}/#{@var2}",1)
end
#--------------------------------------------------------------------------
# * Verifica se a hud precisa atualizar
#--------------------------------------------------------------------------
def necessary?
return true if @var1 != $game_variables[Actual_Bar_Var]
return true if @var2 != $game_variables[Max_Bar_Var]
return true if @color != $gst_boss_bar_color
end
#--------------------------------------------------------------------------
# * Cor primária da hud
#--------------------------------------------------------------------------
def color_hud1
Color.new($gst_boss_bar_color[0],$gst_boss_bar_color[1],$gst_boss_bar_color[2],$gst_boss_bar_color[3])
end
#--------------------------------------------------------------------------
# * Cor secundária da hud
#--------------------------------------------------------------------------
def color_hud2
Color.new($gst_boss_bar_color[0]+25,$gst_boss_bar_color[1]+25,$gst_boss_bar_color[2]+25,$gst_boss_bar_color[3])
end
end
class Scene_Map < Scene_Base
#--------------------------------------------------------------------------
# * Alias
#--------------------------------------------------------------------------
alias :gst_fact_nr_9819_start :start
alias :gst_fact_nr_7821_update :update
alias :gst_fact_nr_1723_terminate :terminate
#--------------------------------------------------------------------------
# * Inicialização do processo
#--------------------------------------------------------------------------
def start
create_hud
gst_fact_nr_9819_start
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
@boss_hud.update
gst_fact_nr_7821_update
end
#--------------------------------------------------------------------------
# * Finalização do processo
#--------------------------------------------------------------------------
def terminate
@boss_hud.dispose
gst_fact_nr_1723_terminate
end
#--------------------------------------------------------------------------
# * Criar a hud
#--------------------------------------------------------------------------
def create_hud
@boss_hud = Boss_FAC_Hud.new
end
end
# Fim do script #
Membro: Miguel8884
Pedido: Queria um script de menu por imagens que permitisse eu remover e adicionar outras opções no menu, em vez de ser a WindowSkin, seria por imagens, mas tipo eu queria que você deixasse na configuração o as cordenadas x e y, para eu poder modificar onde o quadro de opções ficaria, neste menu só quero a janela de gold e o quadro de opção, seria um menu simples, onde se possa configurar a imagem de fundo em vez da WindowSkin e pudesse mover de lugar o quadro de opções.
Imagens: Farei as imagens depois aqui mesmo.
Algo em que se basear: O único que tinha isso oque pedi foi está fora de ar.
Complexidade da configuração: Como dito acima quero configurar as oque aparecera no menu como poder remover opções e adicionar as minhas própria, eu queria que na hora de adicionar as minhas próprias opções eu possa fazer elas por eventos comuns, dai é só colocar o ID do evento comum na linha do script, quero apenas 5 slots para novas opções, as cordenadas, o local do quadro de opções e poder colocar uma imagem em vez da WindowSkin.
Tamanho da tela: 544x416
Informação adicional: Hoje estarei indo para uma viajem de 15 dias, quando terminar o script me mande por MP, para quando eu voltar eu poder ver. Caso seja muito complexo deixa pra lá.
Vou tentar ser rápido para você já poder me esclarecer!
Você quer um menu do zero, apenas o menu onde você possa colocar imagens e tals, as opções você também vai querer por imagens?
Vai querer as opções que já tem do menu e adicionar mais 5 é isso? As opções que já vem você quer que entre nelas normalmente e nas suas por evento comum?
Citação de: miguel8884 online 19/12/2014 às 18:05
Vou tentar ser rápido para você já poder me esclarecer!
Você quer um menu do zero, apenas o menu onde você possa colocar imagens e tals, as opções você também vai querer por imagens?
Vai querer as opções que já tem do menu e adicionar mais 5 é isso? As opções que já vem você quer que entre nelas normalmente e nas suas por evento comum?
Sim um menu do zero, as opções não só o background.
Não quero que você remova as opções, Condição,Salvar e Formação, dai por elas substitui por outras 3 e adiciona mais duas, e quando você acessa elas, aparece o conteúdo que eu irei fazer a eventos comuns.
Citação de: miguel8884 online 19/12/2014 às 17:08
Opa desculpa, eu acabei me esquecendo de passar a imagem :facepalm:!
(http://i.imgur.com/yaEd83v.png)
O script eu coloco a quantidade, não cheguei a colocar por que não pediu, eu vou fazer depois dou um edit, não sei se vai ser agora por que hoje ta bem corrido para mim, mas quando possível!
@edit:
Aqui o script com a quantidade!
Muito Obrigado !! Não consigo textar agora, mas valeu por ter colocado a quantidade também
Citação de: Nick Rock online 19/12/2014 às 20:46
Citação de: miguel8884 online 19/12/2014 às 17:08
Opa desculpa, eu acabei me esquecendo de passar a imagem :facepalm:!
(http://i.imgur.com/yaEd83v.png)
O script eu coloco a quantidade, não cheguei a colocar por que não pediu, eu vou fazer depois dou um edit, não sei se vai ser agora por que hoje ta bem corrido para mim, mas quando possível!
@edit:
Aqui o script com a quantidade!
Muito Obrigado !! Não consigo textar agora, mas valeu por ter colocado a quantidade também
Okay quando testar me envia por mp caso tenha mais alguma coisa sobre o script ou algum bug qualquer coisa!
Citação de: KertonGames online 19/12/2014 às 18:32
Citação de: miguel8884 online 19/12/2014 às 18:05
Vou tentar ser rápido para você já poder me esclarecer!
Você quer um menu do zero, apenas o menu onde você possa colocar imagens e tals, as opções você também vai querer por imagens?
Vai querer as opções que já tem do menu e adicionar mais 5 é isso? As opções que já vem você quer que entre nelas normalmente e nas suas por evento comum?
Sim um menu do zero, as opções não só o background.
Não quero que você remova as opções, Condição,Salvar e Formação, dai por elas substitui por outras 3 e adiciona mais duas, e quando você acessa elas, aparece o conteúdo que eu irei fazer a eventos comuns.
Acho que entendi, quando terminar eu te mando por mp também, aí caso queira que mude alguma coisa!
@Equinho, seu pedido está pronto, desculpa a demora, é por que eu tive uns dias corridos, mas deu para terminar hoje.
Está tudo no script, como usar, eu deixei um pouco mais complexo do que você pediu, mas ainda não está muito dificil de configurar e entender.
Sobre a hud, não fiz nada demais, pois huds costumam demorar mais, se quiser algo mais elaborado, peça mais em um novo pedido, assim coloco ele na lista e faço depois.
#===============================================================================
# Kinsoyo RGSS3 Factory - Pedido de Equinho
#-------------------------------------------------------------------------------
# Ammo_For_Attack
# Por: Miguel8884
#-------------------------------------------------------------------------------
# Intruções:
# Leia a seguir as instruções para usar corretamente o script.
#
# Para tornar uma arma qualquer como uma arma que tem a necessidade de munição,
# apenas escreva em suas notas o seguinte:
#
# Ammo_Type=id
# Sendo que no lugar de id você deve colocar o id no banco de dados de um item,
# somente item, que será necessário e servirá como munição.
#
# Não se esqueça das configurações abaixo!
#-------------------------------------------------------------------------------
# Boa sorte com o uso do script! (:
#===============================================================================
module GST
module Factory
module Equinho
#----------------------------------------------------------------------
# Configurações
#----------------------------------------------------------------------
# Coloque aqui o id dos tipos de armas que serão vistas com a necessidade
# de munição.
Fire_Weapons = [1]
# Alinhamento da HUD na batalha sendo:
# 0 = À esquerda
# 1 = Centralizado
# 2 = À direita
HUD_Align = 0
# X e Y da hud
HUD_XY_Base = [0,96]
#----------------------------------------------------------------------
# Fim das configurações
#----------------------------------------------------------------------
end
end
end
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# * Alias
#--------------------------------------------------------------------------
alias :gst_fact_eq_19281_atk_oeo :on_enemy_ok
#--------------------------------------------------------------------------
# * Ao confirmar ataque perder item (munição)
#--------------------------------------------------------------------------
def on_enemy_ok
if BattleManager.actor.munition_nec1?
$game_party.lose_item($data_items[BattleManager.actor.equips[0].munition_type],1)
end
gst_fact_eq_19281_atk_oeo
end
end
class Bitmap
#--------------------------------------------------------------------------
# * Desenho de ícones no bitmap
#--------------------------------------------------------------------------
def draw_icon(icon_index, x, y)
bitmap = Cache.system("Iconset")
rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
blt(x, y, bitmap, rect)
end
end
class Game_BaseItem
#--------------------------------------------------------------------------
# * Retorna o tipo de munição do item
#--------------------------------------------------------------------------
def munition_type
if object.note.match(/Ammo_Type=(\d+)/im)
return $1.to_i
else
return false
end
end
end
class RPG::BaseItem
#--------------------------------------------------------------------------
# * Retorna o tipo de munição do item
#--------------------------------------------------------------------------
def munition_type
if self.note.match(/Ammo_Type=(\d+)/im)
return $1.to_i
else
return false
end
end
end
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# * Adição na verificação da disponibilidade da skill na batalha
#--------------------------------------------------------------------------
def enable?(item)
@actor && @actor.usable?(item) && @actor.skill_need_munition?(item)
end
end
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# * Alias
#--------------------------------------------------------------------------
alias :gst_fact_eq_19283_atk_us :attack_usable?
#--------------------------------------------------------------------------
# * Adição na verificação da disponibilidade do ataque
#--------------------------------------------------------------------------
def attack_usable?
gst_fact_eq_19283_atk_us
munition_nec?
end
#--------------------------------------------------------------------------
# * Munição necessária para atacar?
#--------------------------------------------------------------------------
def munition_nec?
unless @equips[0].munition_type == false
if $game_party.item_number($data_items[@equips[0].munition_type]) > 0
return true
else
return false
end
else
return true
end
end
#--------------------------------------------------------------------------
# * Munição necessária para atacar? (batalha)
#--------------------------------------------------------------------------
def munition_nec1?
unless @equips[0].munition_type == false
if $game_party.item_number($data_items[@equips[0].munition_type]) > 0
return true
else
return false
end
else
return false
end
end
#--------------------------------------------------------------------------
# * Necessária munição para skill?
#--------------------------------------------------------------------------
def skill_need_munition?(item)
if item.is_a?(RPG::Skill)
GST::Factory::Equinho::Fire_Weapons.each do |fw|
if item.required_wtype_id1 == fw or item.required_wtype_id1 == fw
unless @equips[0].munition_type == false
if $game_party.item_number($data_items[@equips[0].munition_type]) > 0
return true
else
return false
end
else
return true
end
end
end
end
end
end
class Spriteset_Battle
#--------------------------------------------------------------------------
# * Alias
#--------------------------------------------------------------------------
alias :gst_fact_eq_19151_inisb :initialize
alias :gst_fact_eq_19151_updsb :update
alias :gst_fact_eq_19151_dissb :dispose
#--------------------------------------------------------------------------
# * Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
create_ammo
gst_fact_eq_19151_inisb
end
#--------------------------------------------------------------------------
# * Criar hud da munição
#--------------------------------------------------------------------------
def create_ammo
id = 0
@ammo_sprites = []
$game_party.members.each do |s|
if s.equips[0].munition_type != false
item = s.equips[0]
create_ammo_sprite(id,item)
id += 1
end
end
end
#--------------------------------------------------------------------------
# * Atualização da tela
#--------------------------------------------------------------------------
def update
gst_fact_eq_19151_updsb
dispose_ammo_sprites
create_ammo
end
#--------------------------------------------------------------------------
# * Criar sprite único da hud
#--------------------------------------------------------------------------
def create_ammo_sprite(value,item)
sprite = Sprite.new
sprite.bitmap = Bitmap.new(544,24)
case GST::Factory::Equinho::HUD_Align
when 0
sprite.bitmap.draw_icon($data_items[item.munition_type].icon_index,0,0)
sprite.bitmap.draw_text(24,0,544,24,"#{$game_party.item_number($data_items[item.munition_type])}")
sprite.x = GST::Factory::Equinho::HUD_XY_Base[0]
sprite.y = GST::Factory::Equinho::HUD_XY_Base[1]+(24*value)
sprite.z = 99
when 1
sprite.bitmap.draw_icon($data_items[item.munition_type].icon_index,(544-34)/2,0)
sprite.bitmap.draw_text(24,0,544,24,"#{$game_party.item_number($data_items[item.munition_type])}",1)
sprite.x = GST::Factory::Equinho::HUD_XY_Base[0]
sprite.y = GST::Factory::Equinho::HUD_XY_Base[1]+(24*value)
sprite.z = 99
when 2
sprite.bitmap.draw_icon($data_items[item.munition_type].icon_index,544-24,0)
sprite.bitmap.draw_text(-24,0,544,24,"#{$game_party.item_number($data_items[item.munition_type])}",2)
sprite.x = GST::Factory::Equinho::HUD_XY_Base[0]
sprite.y = GST::Factory::Equinho::HUD_XY_Base[1]+(24*value)
sprite.z = 99
end
@ammo_sprites.push(sprite)
end
#--------------------------------------------------------------------------
# * Apagar sprites da hud de munição
#--------------------------------------------------------------------------
def dispose_ammo_sprites
@ammo_sprites.each do |spr|
spr.bitmap.dispose
spr.dispose
end
end
#--------------------------------------------------------------------------
# * Modificação para apagar HUD
#--------------------------------------------------------------------------
def dispose
gst_fact_eq_19151_dissb
dispose_ammo_sprites
end
end
# Fim do script #
@ArrowPotter seu pedido também está pronto:
Eu coloquei para você definir a quantidade de verificações que serão feitas para impedir números iguais, apenas leia as instruções e saberá facilmente manusear o script
#===============================================================================
# Kinsoyo RGSS3 Factory - Pedido de ArrowPotter
#-------------------------------------------------------------------------------
# Variables Sort Numbers
# Por: Miguel8884
#-------------------------------------------------------------------------------
# Intruções:
#
# Para sortear os números em variáveis, utilize o seguinte comando apenas em
# um chamar script:
# set_vars_value_sort(id)
# Sendo id o id da configuração criada nas configurações!
# Exemplo:
# Eu criei o seguinte:
#
# Var_Sort[0] = [
# Vars_Id = [1,2,3,4,5],
# Numbers = [1,14],
# ]
#
# Vou colocar no lugar de id do comando o número 0 para sortear de 1 até 14
# nas variáveis 1,2,3,4 e 5
#-------------------------------------------------------------------------------
# Boa sorte com o uso do script! (:
#===============================================================================
module GST
module Factory
module ArrowPotter
Var_Sort = Array.new
#----------------------------------------------------------------------
# Configurações
#----------------------------------------------------------------------
# Coloque aqui o número de verificações que deseja que o sistema faça
# para impedir que os número acabem sendo iguais
# Não extrapole no número, pode travar o jogo
# Padrão 10
Scan_Amount = 100
# Coloque o id dessa configuração
Var_Sort[0] = [
# Coloque o id de todas as variáveis que receberão o valor aleatório
Vars_Id = [1,2,3,4,5],
# Coloque de qual até qual número serão sorteados nas variáveis
Numbers = [1,14],
]
#----------------------------------------------------------------------
# Fim das configurações
#----------------------------------------------------------------------
end
end
end
class Object
#--------------------------------------------------------------------------
# * Criação de um novo método onde o aleatório parti de um minimo
#--------------------------------------------------------------------------
def rand!(value,min)
var = rand(value)
if var < min
var += min
end
return var
end
end
class Game_Interpreter
#--------------------------------------------------------------------------
# * Método de sorteio das variáveis
#--------------------------------------------------------------------------
def set_vars_value_sort(id)
data = GST::Factory::ArrowPotter::Var_Sort[id]
values = Array.new
min_max = [data[1][0],data[1][1]]
data[0].each_index do |dt|
values[dt] = rand!(min_max[1]+1,min_max[0])
end
GST::Factory::ArrowPotter::Scan_Amount.times do |test|
values.each_index{|item|
values.each_index do |i|
unless item == i
if values[item] == values[i]
values[item] = rand!(min_max[1]+1,min_max[0])
end
end
end
}
end
data[0].each do |it|
$game_variables[it] = values[data[0].index(it)]
end
end
end
# Fim do script #
Thanks vou testar!!!
Vou ver se deu certo, por eventos fica paralisando eu meio que fiz o sorteio de um em um e criei uma label para cada uma variável, ai se o valor da variável for igual a qualquer uma das ids anteriores (criei uma condição para cada um o que foi bem maçante) e se fosse igual voltaria a label. Só que paralisava o jogo.
Primeiramente, quero pedir drsculpas pelo post duplo, mas como ninguém conseguiu me ajudar no tópico de suporte, vi aqui na fábrica de scripts uma esperança pro meu problema.
Bem, utilizo o script Akea Battle System do Rayzem, mas precisava que ele fosse editadopara resolver um probleminha
Seguinte: Logo no começo do script encontramos a seguinte tela:Spoiler
(http://i57.tinypic.com/6p94ya.png)
Spoiler
(http://i62.tinypic.com/2ajym9x.jpg)
Spoiler
(http://i57.tinypic.com/351fssh.png)
:T.T: :T.T:
Citação de: ArrowPotter online 21/12/2014 às 20:55
Thanks vou testar!!!
Vou ver se deu certo, por eventos fica paralisando eu meio que fiz o sorteio de um em um e criei uma label para cada uma variável, ai se o valor da variável for igual a qualquer uma das ids anteriores (criei uma condição para cada um o que foi bem maçante) e se fosse igual voltaria a label. Só que paralisava o jogo.
Tranquilo, foi um script divertido até de fazer, precisando, só pedir!
Citação de: vitorano online 21/12/2014 às 21:16
Primeiramente, quero pedir drsculpas pelo post duplo, mas como ninguém conseguiu me ajudar no tópico de suporte, vi aqui na fábrica de scripts uma esperança pro meu problema.
Bem, utilizo o script Akea Battle System do Rayzem, mas precisava que ele fosse editadopara resolver um probleminha
Seguinte: Logo no começo do script encontramos a seguinte tela:
Spoiler
(http://i57.tinypic.com/6p94ya.png)
Nela, eu coloco a quantidade máxima de frames que o battler terá, sendo ele a do Inimigo ou do Heroi.
Pois bem, aí é que vem o dilema, observem a imagem do battler:
Spoiler
(http://i62.tinypic.com/2ajym9x.jpg)
Meu battler de inimigo enquanto está na animação de "Stand", ou seja, aguardando, possui 9 frames, assim como na imagem (É a primeira linha, ela fica mandando beijinho pros adversarios, muito maneiro né? :D).
Acontece que o meu herói nao tem 9 frames para essa animação, mas apenas 6, como na imagem abaixo:
Spoiler
(http://i57.tinypic.com/351fssh.png)
Ou seja, sou obrigado há duas coisas:
1° Escolher abrir mao dos ultimos 3 frames de animação do inimigo recontando o sprite em algum editor de imagens para igualar com o sprite do heroi ou...
2° Escolher repetir frames em um editor de imagens para sprite do heroi se igualar ao do inimigo
Nehuma dessa opções é 100% perfeita, por isso venho pedir:
Por favor, seria possivel editar este script para que cada Inimigo e Heroi tivessem suas configurações individuais ?
:T.T: :T.T:
Eu não posso confirmar nada para você, eu posso dar uma olhada e ver o que da para fazer, daria uns 30% de chance de dar certo... Mas espere, quem sabe.
Desculpe eu sei que você já deve ter ums mil pedidos (que exagero) mas eu preciso de um script assim !
Membro: miguel8884
Pedido: Um sistema de batalha com tudo normal , a unica coisa que eu queria que mudase era a forma de apertar os controles para atacar , queria que fosse redondo apenas isso !
Imagens:
Spoiler
(http://i.imgur.com/Uv0T4ab.png)
Algo em que se basear: Slá nada , quero que seja bem simples para não dar trabalho !
Complexidade da configuração: Que seja bem simples como citei acima , não quero que mude nada da batalha do Rpg maker , apenas o formato dos comando para atacar de quadrado para redondo
Tamanho da tela: slá , 544X416
Obrigado dês de já !
CitarEu não posso confirmar nada para você, eu posso dar uma olhada e ver o que da para fazer, daria uns 30% de chance de dar certo... Mas espere, quem sabe.
@miguel8884 de qualquer forma, muito obrigado desde já pela atenção, você é minha última esperança
Obrigado :'0': Ficou Perfeito :*-*: :rainbow: Pena que nao posso dar +100 Ouro :T.T: Mas Deixo +1 :ded: Obrigado De novo !!! :wow:
Nome: Equinho
Pedido: Adaptação de um Script do RD12
Engine: RPG Maker VX Ace
Descrição: Quero uma Adaptação do Script "Fome" do RD12 para "Sede" e assim se possivel ter como edita-lo para aparecer o nome do Heroi e a fome tipo Encima da HUD Aparecer Assim "Fome de Zack" Tipo Isso :hmm: nao sei explicar direito :¬¬: e se conseguir adaptar o script de fome para sede eu quero a mesma coisa so muda que "Sede de Zack" ou seja quero 2 script um de fome e um de sede so que adaptado do jeito que descrevi acima :rei: :=p: :*-*: Espero 1 Semana ou mais :wow: :XD:
o Script é esse!
Esqueci de Mais uma Coisa, Eu Quero que quando diminua a fome ou a sede nao abra uma janela e sim quero que mostre uma mensagem falando que foi diminuido pois abrindo janela fica muito feio :será:
Pois do nada voce esta jogando em full screen e quando vai diminuir a fome ou a sede o jogo sai do fullscreen e abre uma janela mostrando que fome ou sede foi diminuido isso fica feio :T.T: então se possivel que a mensagem que diminui a fome ou a sede mostre dentro do jogo!
Spoiler
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Script de Fome
#|Autor: RD12|
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# A fome vai de 0 a 100, quanto maior o valor mais com fome o membro estará
# Se a fome chegar no 100 o membro irá fifcar com hp=0 (morre)
#
# Para um item diminuir a fome bote em sua Nota: -fome valor
# E para um item aumentar a fome, bote na nota: +fome valor
module Fome
#Tempo em segundos que irá aumentar a fome
Segundos = 300
#Valor que irá aumentar de fome para cada personagem
Actor = []#Declara a var
Actor[0] = 7 #Primeiro personagem
Actor[1] = 6 #Segundo
Actor[2] = 4 #Terceiro
Actor[3] = 11#Quarto
#Actor[4] = 11#Quinto
#Modifique a posição da Hud aqui
HUDs_x = 1
HUDs_y = 190
end
#===========================================================================================
#Hud da fome dos jogadores
class Hud_Fome < Sprite
def initialize
super
self.bitmap = bitmap = Bitmap.new(100,300)
self.bitmap.font.size = 14
self.bitmap.font.name = "Segoe UI"
self.x = Fome::HUDs_x
self.y = Fome::HUDs_y
refresh
end
def update
super
refresh
end
def refresh
self.bitmap.clear
for i in 0..$game_party.members.size-1
@actor = $game_party.members
base = Cache.picture("Fome_Base")
rect = Rect.new(0,0,base.width,base.height)
self.bitmap.blt(10,21+30*i,base,rect)
self.bitmap.draw_text(10, 30*i, 100, 32, @actor.name, 0)
if @actor.fome >= 100
@actor.hp = 0
hud_name = "Fome_100"
else
hud_name = "Fome_Hud"
end
base = Cache.picture(hud_name)
rect = Rect.new(0,0,base.width * @actor.fome / 100,base.height)
self.bitmap.blt(10,21+30*i,base,rect)
end
end
end
#===========================================================================================
#Atualiza a Hud e Aumenta a fome de acordo com o tempo configurado
class Scene_Map
alias rd12_main main
def main
$Fome = Hud_Fome.new
@segundos = 0
rd12_main
$Fome.dispose
end
alias rd12_update update
def update
if Graphics.frame_count % 60 == 0
@segundos += 1
end
if @segundos == Fome::Segundos
for i in 0..$game_party.members.size-1
$game_party.members.fome = (Fome::Actor)
end
@segundos = 0
end
rd12_update
end
end
#===========================================================================================
#Adiciona a fome nos personagens
class Game_Actor < Game_Battler
alias rd12_initialize initialize
def initialize(actor_id)
@fome = 0
rd12_initialize(actor_id)
end
def fome=(arg)
@fome = 0 if @fome == nil
@fome += arg
@fome = 0 if @fome < 0
$Fome.refresh
end
def fome
@fome
end
end
#===========================================================================================
#Modifica o método para poder usar o item de fome
class Game_Battler < Game_BattlerBase
def item_test(user, item)
return false if item.for_dead_friend? != dead?
return true if $game_party.in_battle
return true if item.for_opponent?
return true if item.damage.recover? && item.damage.to_hp? && hp < mhp
return true if item.damage.recover? && item.damage.to_mp? && mp < mmp
return true if item_has_any_valid_effects?(user, item)
arg = item.note.split
return true if arg[0] == "-fome" or arg[0] == "+fome"
return false
end
end
#===========================================================================================
#Modifica o método para ganhar ou perder Fome
class Scene_Item < Scene_ItemBase
def use_item_to_actors
item_target_actors.each do |target|
arg = item.note.split
if arg[0] == "-fome"
target.fome = -arg[1].to_i
#Mostra mensagem com a fome atual
msgbox("Fome diminuída em -#{arg[1]}\n","Fome atual: #{target.fome}/100")
end
if arg[0] == "+fome"
target.fome = arg[1].to_i
#Mostra mensagem com a fome atual
msgbox("Fome aumentada em +#{arg[1]}\n","Fome atual: #{target.fome}/100")
end
item.repeats.times { target.item_apply(user, item) }
end
end
end
#===========================================================================================
Membro: miguel8884
Pedido: Eu queria um script que salvasse o jogo automaticamente quando saísse.
Algo em que se basear: É basicamente o mesmo que esse: http://centrorpg.com/index.php?topic=5536.0 (http://centrorpg.com/index.php?topic=5536.0) mas eu queria que salvasse só na hora de sair do jogo.
Complexidade da configuração: Pode ser o básico, acho que não via fazer muita diferença.
Membro: miguel8884
Pedido: Tem como voce fazer um sistema de pontos de vida? exemplo: Em uma batalha, luta, etc, na tela lá em cima tenha os pontos de vida de cada JOGADOR e a cada dano os pontos de vida são reduzidos pela diferença dos pontos de ataque com a defesa ou com magia, poder, etc os pontos de vida aumentam.
Exemplo: Goku e vegeta estão lutando, e na tela da luta os pontos de vida de cada um é de 500 e estão lá em cima na tela, goku com 50 pontos de ataque, ataca o vegeta com 49 pontos de defesa e a diferença dos pontos são reduzidos nos pontos de vida do JOGADOR atacado ( 500 - 1 = 499, obvio kkkk )
Exemplo 2: Goku usa um poder que aumenta seus pontos de vida em 30 ( 500 + 30 = 530 ).
Complexidade da configuração: Pode ser básico.
Membro: Aquele que tiver um bom coração
Pedido: Character Layers!
Olá ^^ Bem eu tô precisando de um script que faça com que o herói tenha mais de um charset, tipo um visual equipe, mas sem configurar tags nas armas porque eu quero poder trocar esse gráfico a todo momento.
Ai você pensa por que isso? Eu estou fazendo um ABS por eventos e o personagem tem uma animações e tals só que eu quero que a arma e a armadura apareçam.
Vou explicar um pouco mais sobre o script, nele você configura quantidade de camadas que você quer para o herói, ai essas camadas são configuradas pelo evento chamar script; Um pequeno exemplo:
(http://i1379.photobucket.com/albums/ah156/Will_Saymon/00000_zps0b9536c9.png)
Tomara que não seja trabalhoso fazer esse script, tô precisando muito dele ><
Complexidade da configuração: Médio
Tamanho da tela: Padrão
Membro: Miguel8884
Pedido: Eu gostaria de um sistema estilo a mochila do harvest moon, com lugar para itens e ferramentas, de maneira que eu possa pegar os itens e guardar nela.
[Anexo excluído pelo administrador]
@Dr@gon
Spoiler
Citação de: Dr@gon online 21/12/2014 às 21:40
Desculpe eu sei que você já deve ter ums mil pedidos (que exagero) mas eu preciso de um script assim !
Membro: miguel8884
Pedido: Um sistema de batalha com tudo normal , a unica coisa que eu queria que mudase era a forma de apertar os controles para atacar , queria que fosse redondo apenas isso !
Imagens: Spoiler
(http://i.imgur.com/Uv0T4ab.png)
Complexidade da configuração: Que seja bem simples como citei acima , não quero que mude nada da batalha do Rpg maker , apenas o formato dos comando para atacar de quadrado para redondo
Tamanho da tela: slá , 544X416
Obrigado dês de já !
Acho que o mog tem uns scripts que pode te ajudar a criar isso ai.
@Miguel8884 ainda esta fazendo esse pedido aqui ou esta livre para aceitar pedidos?
Citação de: KertonGames online 19/12/2014 às 17:24
Membro: Miguel8884
Pedido: Queria um script de menu por imagens que permitisse eu remover e adicionar outras opções no menu, em vez de ser a WindowSkin, seria por imagens, mas tipo eu queria que você deixasse na configuração o as cordenadas x e y, para eu poder modificar onde o quadro de opções ficaria, neste menu só quero a janela de gold e o quadro de opção, seria um menu simples, onde se possa configurar a imagem de fundo em vez da WindowSkin e pudesse mover de lugar o quadro de opções.
Imagens: Farei as imagens depois aqui mesmo.
Algo em que se basear: O único que tinha isso oque pedi foi está fora de ar.
Complexidade da configuração: Como dito acima quero configurar as oque aparecera no menu como poder remover opções e adicionar as minhas própria, eu queria que na hora de adicionar as minhas próprias opções eu possa fazer elas por eventos comuns, dai é só colocar o ID do evento comum na linha do script, quero apenas 5 slots para novas opções, as cordenadas, o local do quadro de opções e poder colocar uma imagem em vez da WindowSkin.
Tamanho da tela: 544x416
Informação adicional: Hoje estarei indo para uma viajem de 15 dias, quando terminar o script me mande por MP, para quando eu voltar eu poder ver. Caso seja muito complexo deixa pra lá.
Já faz mais de um mês que fiz meu pedido e nem tive resposta, se o dono da fábrica está tão ocupado a ponto de nem se dignar a responder o pedido tranquem logo esse tópico. Aliás esse script era essencial para meu projeto que depois de tanto tempo parado acabei desistindo dele. Miguel, obrigado por nada.
Citação de: BrunoGueira online 10/02/2015 às 17:39
Já faz mais de um mês que fiz meu pedido e nem tive resposta, se o dono da fábrica está tão ocupado a ponto de nem se dignar a responder o pedido tranquem logo esse tópico. Aliás esse script era essencial para meu projeto que depois de tanto tempo parado acabei desistindo dele. Miguel, obrigado por nada.
Que feio...o cara tem seus motivos, uma hora ele aparece pra ajudar : )
Sim como o hategum disse, eu tive sim meus motivos para ter abandonado por um tempo o fórum, não acho que você deveria ter se estressado por isso, afinal a fábrica está aqui para ajudar, não para ser escrava de ninguém e ser obrigada a fazer os pedidos, eu não pude ajudar nesses tempos, posso até tentar agora, mas antes tem algumas coisas para acertar, e não quero mais receber pedidos por enquanto.