[XP] Mapa no Menu

BillyKharles · 21/02/2023 às 21:45

Olá!
Eu estou com uma dúvida enorme e não manjo nada de scripts. :/
Eu gostaria de colocar um mapa no menu do meu projeto (eu uso somente o XP).
Eu até encontrei um script muito bom que coloca a opção de mapa no menu, porém é uma opção inútil no menu, pois não faz nada.
Eu não queria perder esse menu, pois ele combina muito com meu projeto.
Eu gostaria de um mapa que pudesse ser liberado no menu assim que o jogador achasse ele durante o jogo, sendo por switch ou pelo item mesmo.
Tenho até uma imagem de mapa, mas não consigo por

O Menu que eu uso é esse:

Spoiler

#==============================================================================
# Menu do Sistema de Tiro
#------------------------------------------------------------------------------
# Insere um menu customizado ao seu jogo, criado especialmente para funcionar
# em compatibilidade com o Sistema de Tiro criado por cristianoforce.
#------------------------------------------------------------------------------
# Site : http://www.mundorpgmaker.com/
# Autor : Kyo Panda
# Versão :
# Lançado em :
# Atualização :
#==============================================================================

#==============================================================================
# Shoot_SystemSettings
#------------------------------------------------------------------------------
# Módulo de configuração para o Menu do Sistema de Tiro.
#==============================================================================

module Shoot_SystemSettings
#--------------------------------------------------------------------------
# Início da configuração
#--------------------------------------------------------------------------
# Defina aqui os nomes dos comandos do Menu do Sistema de tiro.
# ID : Index do comando
# "Nome" : Nome do comando
MENU_COMMANDS = {

# ID => "Nome",
0 => "Item", # Item
1 => "Equipamentos", # Equipamentos
2 => "Mapa", # Mapa
3 => "Sair", # Sair
} # Não remova isto!

# Defina aqui as propriedades das armas utilizadas para o menu.
# Mantenha como 0 quando não houver armas.
# O modo de se definir isso:
# Swi : ID da switch que indica que a arma está equipada.
# Imagem : Imagem da arma localizada na pasta Graphics/Pictures.
# Nome : Nome da arma
# MIV : ID da variável que armazena o número máximo de balas da arma.
# IID : ID do item que simboliza a munição da arma.

MENU_GUN_PROPERTIES = {

# Swi => [ Imagem , Nome , MIV, IID],
0 => ["HUD de Arma Vazia" , "Nada" , 0, 0],
1 => ["HUD de Arma Faca" , "Faca" , 0, 0],
10 => ["HUD de Arma Handgun", "Pistola", 14, 1],
11 => ["HUD de Arma Shotgun", "Shotgun", 16, 3],
12 => ["HUD de Arma Magnum" , "Magnum" , 17, 4],
13 => ["HUD de Arma Rifle" , "Rifle" , 15, 2],
} # Não remova isto!

# Defina aqui as propriedades da janela de comandos do menu.
# Lar : Largura da janela
# X : Posicionamento horizontal da janela
# Y : Posicionamento vertical da janela
# Fonte : Fonte da janela

# [ X , Fonte ]
MENU_COMMAND_WINDOW = [ 0 , "Calibri"]

# Defina aqui as propriedades da janela de tempo do menu.
# Lar : Largura da janela
# Alt : Altura da janela
# X : Posicionamento horizontal da janela
# Texto : Texto da janela
# Fonte : Fonte da janela

# [ X , Texto , Fonte ]
MENU_TIME_WINDOW = [ 0 , "Tempo de Jogo", "Calibri"]

# Defina aqui as propriedades da janela de status do menu.
# X : Posicionamento horizontal da janela
# Fonte : Fonte da janela

# [ X , Fonte ]
MENU_STATUS_WINDOW = [ 0 , "Calibri"]

# Defina aqui as propriedades da janela de mapa do menu.
# X : Posicionamento horizontal da janela
# Fonte : Fonte da janela

# [ X , Fonte ]
MENU_MAP_WINDOW = [ 0 , "Calibri"]

# Defina aqui as propriedades da janela de ajuda do menu.
# X : Posicionamento horizontal da janela
# Fonte : Fonte da janela

# [ X , Fonte ]
MENU_HELP_WINDOW = [160, "Calibri"]

# Defina aqui as propriedades da janela de seleção de item do menu.
# X : Posicionamento horizontal da janela
# Fonte : Fonte da janela

# [ X , Fonte ]
MENU_ITEM_COMMAND_WINDOW = [160, "Calibri"]

# Defina aqui as propriedades da janela de seleção de equipamentos do menu.
# X : Posicionamento horizontal da janela
# Fonte : Fonte da janela

# [ X , Fonte ]
MENU_EQUIP_COMMAND_WINDOW = [160, "Calibri"]

# Defina aqui as propriedades da janela de escolha do menu.
# Fonte : Fonte da janela

# [ Fonte ]
MENU_CHOICE_WINDOW = ["Calibri"]
#--------------------------------------------------------------------------
# Fim da configuração
#--------------------------------------------------------------------------
end

#==============================================================================
# Scene_Menu
#------------------------------------------------------------------------------
# Esta classe processa a Tela de Menu
#==============================================================================

class Scene_Menu
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# Inicialização do objeto
# menu_index : Posição inicial do cursor de comando
#--------------------------------------------------------------------------
def initialize(menu_index = 0)
@menu_index = menu_index
end
#--------------------------------------------------------------------------
# Processamento principal
#--------------------------------------------------------------------------
def main
# Criar janela de comando
commands = []
MENU_COMMANDS.each{|key, value| commands[key] = value}
@command_window = Window_MenuCommand.new(160, commands)
@command_window.x = MENU_COMMAND_WINDOW[0]
@command_window.y = 0
@command_window.contents.font.name = MENU_COMMAND_WINDOW[1]
@command_window.refresh
@command_window.index = @menu_index
# Se o número de membros do grupo de heróis for 0
if $game_party.actors.size == 0
# Desabilitar as janelas de item e equipamento
@command_window.disable_item(0)
@command_window.disable_item(1)
end
# Se salvar for proibido
if $game_system.save_disabled
# Desabilitar salvar
@command_window.disable_item(3)
end
# Criar a janela de tempo de jogo
@playtime_window = Window_MenuPlayTime.new
@playtime_window.x = MENU_TIME_WINDOW[0]
@playtime_window.y = @command_window.height
# Criar a janela de status
@status_window = Window_ShootStatus.new
@status_window.x = MENU_STATUS_WINDOW[0]
@status_window.y = @playtime_window.y + @playtime_window.height
# Criar a janela de mapa
@map_window = Window_MenuMapName.new
@map_window.x = MENU_MAP_WINDOW[0]
@map_window.y = @status_window.y + @status_window.height
# Criar a janela de ajuda
@help_window = Window_MenuHelp.new
@help_window.x = MENU_HELP_WINDOW[0]
@help_window.y = 424
@help_window.width = 480
@help_window.height = 56
@help_window.contents = Bitmap.new(448, 24)
@help_window.contents.font.name = MENU_HELP_WINDOW[1]
# Criar a janela de itens
@item_window = Window_Item.new
@item_window.index = -1
@item_window.active = false
@item_window.visible = false
@item_window.help_window = @help_window
# Criar a janela de escolha de itens
@item_command_window = Window_ItemCommand.new
@item_command_window.x = MENU_ITEM_COMMAND_WINDOW[0]
@item_command_window.y = 0
@item_command_window.index = -1
@item_command_window.active = false
@item_command_window.visible = false
# Criar janela de equipamentos para armas
@equip_weapon_window = Window_MenuEquipItem.new($game_party.actors[0], 0)
@equip_weapon_window.index = -1
@equip_weapon_window.active = false
@equip_weapon_window.visible = false
# Criar janela de equipamentos para armaduras
@equip_armor_window = Window_MenuEquipItem.new($game_party.actors[0], 1)
@equip_armor_window.index = -1
@equip_armor_window.active = false
@equip_armor_window.visible = false
# Criar a janela de escolha de equipamentos
@equip_command_window = Window_EquipCommand.new
@equip_command_window.x = MENU_EQUIP_COMMAND_WINDOW[0]
@equip_command_window.y = 0
@equip_command_window.index = -1
@equip_command_window.active = false
@equip_command_window.visible = false
# Janela de seleção
@choice_window = Window_Choice.new("", "Sim", "Não")
# Executar transição
Graphics.transition
# Loop principal
loop do
# Atualizar a tela de jogo
Graphics.update
# Atualizar a entrada de informações
Input.update
# Atualizar Frame
update
# Abortar loop se a tela for alterada
if $scene != self
break
end
end
# Preparar para transiçõa
Graphics.freeze
# Exibição das janelas
@command_window.dispose
@playtime_window.dispose
@status_window.dispose
@map_window.dispose
@help_window.dispose
@item_window.dispose
@item_command_window.dispose
@equip_weapon_window.dispose
@equip_armor_window.dispose
@equip_command_window.dispose
@choice_window.dispose
end
#--------------------------------------------------------------------------
# Atualização do Frame
#--------------------------------------------------------------------------
def update
# Atualizar janelas
@command_window.update
@playtime_window.update
@status_window.update
@map_window.update
@item_window.update
@item_command_window.update
@equip_weapon_window.update
@equip_armor_window.update
@equip_command_window.update
@item_window.visible = @command_window.index == 0
@item_command_window.visible = @command_window.index == 0
if @command_window.index == 1
@equip_command_window.visible = true
@equip_armor_window.visible = @equip_command_window.index == 1
@equip_weapon_window.visible = true if @equip_command_window.index == -1
@equip_weapon_window.visible = true if @equip_command_window.index == 0
@equip_weapon_window.visible = false if @equip_command_window.index == 1
@equip_weapon_window.visible = true if @equip_command_window.index == 2
else
@equip_weapon_window.visible = false
@equip_armor_window.visible = false
@equip_command_window.visible = false
end
@choice_window.update
if @command_window.active
update_command
elsif @item_command_window.active
update_item_command_selection
elsif @item_window.active
update_item_selection
elsif @equip_command_window.active
update_equip_command_selection
elsif @equip_weapon_window.active
update_weapon_selection
elsif @equip_armor_window.active
update_armor_selection
elsif @choice_window.active
update_choice_selection
end
end
#--------------------------------------------------------------------------
# Atualização da janela de comandos
#--------------------------------------------------------------------------
def update_command
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
$scene = Scene_Map.new
return
end
if Input.trigger?(Input::C)
if $game_party.actors.size == 0 and @command_window.index < 4
$game_system.se_play($data_system.buzzer_se)
return
end
case @command_window.index
when 0 # Itens
$game_system.se_play($data_system.decision_se)
@item_command_window.index = 0
@command_window.active = false
@item_command_window.active = true
when 1 # Equipamentos
$game_system.se_play($data_system.decision_se)
@equip_command_window.index = 0
@command_window.active = false
@equip_command_window.active = true
end
return
end
end
#--------------------------------------------------------------------------
# Atualização da seleção de escolha de itens
#--------------------------------------------------------------------------
def update_item_command_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@item_command_window.index = -1
@item_command_window.active = false
@command_window.active = true
elsif Input.trigger?(Input::C)
case @item_command_window.index
when 0, 1 # Utilizar, Descartar
$game_system.se_play($data_system.decision_se)
@item_window.index = 0
@item_command_window.active = false
@item_window.active = true
when 2 # Retornar
$game_system.se_play($data_system.cancel_se)
@item_command_window.index = -1
@item_command_window.active = false
@command_window.active = true
end
end
end
#--------------------------------------------------------------------------
# Atualização da seleção de escolha de equipamentos
#--------------------------------------------------------------------------
def update_equip_command_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@equip_command_window.index = -1
@equip_command_window.active = false
@command_window.active = true
elsif Input.trigger?(Input::C)
case @equip_command_window.index
when 0 # Armas
if $game_party.actors[0].equip_fix?(0)
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
@equip_weapon_window.index = 0
@equip_command_window.active = false
@equip_weapon_window.active = true
when 1 # Roupas
if $game_party.actors[0].equip_fix?(3)
$game_system.se_play($data_system.buzzer_se)
return
end
$game_system.se_play($data_system.decision_se)
@equip_armor_window.index = 0
@equip_command_window.active = false
@equip_armor_window.active = true
when 2 # Retornar
$game_system.se_play($data_system.cancel_se)
@equip_command_window.index = -1
@equip_command_window.active = false
@command_window.active = true
end
end
end
#--------------------------------------------------------------------------
# Atualização da seleção de itens
#--------------------------------------------------------------------------
def update_item_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@item_window.index = -1
@item_window.active = false
@item_command_window.active = true
elsif Input.trigger?(Input::C)
@item = @item_window.item
case @item_command_window.index
when 0 # Utilizar
if !@item.is_a?(RPG::Item) || !$game_party.item_can_use?(@item.id)
$game_system.se_play($data_system.buzzer_se)
return
end
if @item.scope >= 3
if @item.scope == 4 || @item.scope == 6
used = false
for i in $game_party.actors
used |= i.item_effect(@item)
end
else
target = $game_party.actors[0]
used = target.item_effect(@item)
end
if used
$game_system.se_play(@item.menu_se)
if @item.consumable
$game_party.lose_item(@item.id, 1)
@item_window.draw_item(@item_window.index)
end
if $game_party.all_dead?
$scene = Scene_Gameover.new
return
end
if @item.common_event_id > 0
$game_temp.common_event_id = @item.common_event_id
$scene = Scene_Map.new
return
end
end
unless used
$game_system.se_play($data_system.buzzer_se)
end
@status_window.refresh
@item_window.refresh
end
when 1 # Descartar
if @item.nil? || @item.price <= 0
$game_system.se_play($data_system.buzzer_se)
return
else
$game_system.se_play($data_system.decision_se)
@item_window.active = false
text = "Tem certeza que deseja descartar #{@item.name}?"
@choice_window.set_text(text)
@choice_window.x = (640 - @choice_window.width) / 2
@choice_window.y = (480 - @choice_window.height) / 2
@choice_window.index = 0
@choice_window.visible = true
@choice_window.active = true
end
end
end
end
#--------------------------------------------------------------------------
# Atualização da seleção de armas
#--------------------------------------------------------------------------
def update_weapon_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@equip_weapon_window.index = -1
@equip_weapon_window.active = false
@equip_command_window.active = true
elsif Input.trigger?(Input::C)
$game_system.se_play($data_system.equip_se)
item = @equip_weapon_window.item
$game_party.actors[0].equip(0, item == nil ? 0 : item.id)
$game_map.update_common_events
@status_window.refresh
@equip_weapon_window.refresh
end
end
#--------------------------------------------------------------------------
# Atualização da seleção de armaduras
#--------------------------------------------------------------------------
def update_armor_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@equip_armor_window.index = -1
@equip_armor_window.active = false
@equip_command_window.active = true
elsif Input.trigger?(Input::C)
$game_system.se_play($data_system.equip_se)
item = @equip_armor_window.item
$game_party.actors[0].equip(3, item == nil ? 0 : item.id)
$game_map.update_common_events
@status_window.refresh
@equip_armor_window.refresh
end
end
#--------------------------------------------------------------------------
# Atualização da seleção de escolha
#--------------------------------------------------------------------------
def update_choice_selection
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@choice_window.active = false
@choice_window.visible = false
@item_window.active = @item_window.visible
elsif Input.trigger?(Input::C)
case @choice_window.index
when 0 # Sim
$game_system.se_play($data_system.decision_se)
@choice_window.active = false
@choice_window.visible = false
if @item_window.visible
case @item
when RPG::Item
$game_party.lose_item(@item.id, $game_party.item_number(@item.id))
when RPG::Armor
$game_party.lose_armor(@item.id, $game_party.armor_number(@item.id))
when RPG::Weapon
$game_party.lose_weapon(@item.id, $game_party.weapon_number(@item.id))
end
@item_window.refresh
@item_window.active = true
end
when 1 # Não
$game_system.se_play($data_system.cancel_se)
@choice_window.active = false
@choice_window.visible = false
@item_window.active = @item_window.visible
end
end
end
end

#==============================================================================
# Game_Map
#------------------------------------------------------------------------------
# Esta classe engloba o . Isso determina o Scroll e a determinante de
# passagem. Se refere a $game_map para as instâncias desta classe.
#==============================================================================

class Game_Map
#--------------------------------------------------------------------------
# Atualização dos eventos comuns
#--------------------------------------------------------------------------
def update_common_events
for common_event in @common_events.values
common_event.update
end
end
end

#==============================================================================
# Window_MenuCommand
#------------------------------------------------------------------------------
# Esta é a janela que exibe as escolhas no menu.
#==============================================================================

class Window_MenuCommand < Window_Command
#--------------------------------------------------------------------------
# Inicialização dos objetos
# width : Largura da janela
# commands : Ordem dos comandos
#--------------------------------------------------------------------------
def initialize(width, commands)
super(width, commands)
self.height = commands.size * 24 + 32
self.contents = Bitmap.new(width - 32, @item_max * 24)
refresh
end
#--------------------------------------------------------------------------
# Desenhar item
# index : Index do item
# color : Cor do texto
#--------------------------------------------------------------------------
def draw_item(index, color)
self.contents.font.color = color
rect = Rect.new(4, 24 * index, self.contents.width - 8, 24)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[index])
end
#--------------------------------------------------------------------------
# Aquisição de uma linha superior
#--------------------------------------------------------------------------
def top_row
return self.oy / 24
end
#--------------------------------------------------------------------------
# Definição da linha superior
# row : Linha do Cabeçalho
#--------------------------------------------------------------------------
def top_row=(row)
row = 0 if row < 0
row = row_max - 1 if row > row_max - 1
self.oy = row * 24
end
#--------------------------------------------------------------------------
# Definição do número de linhas que podem ser mostradas em uma página
#--------------------------------------------------------------------------
def page_row_max
return (self.height - 32) / 24
end
#--------------------------------------------------------------------------
# Atualização do cursor
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
return
end
row = @index / @column_max
if row < self.top_row
self.top_row = row
end
if row > self.top_row + (self.page_row_max - 1)
self.top_row = row - (self.page_row_max - 1)
end
cursor_width = self.width / @column_max - 32
x = @index % @column_max * (cursor_width + 32)
y = @index / @column_max * 24 - self.oy
self.cursor_rect.set(x, y, cursor_width, 24)
end
end

#==============================================================================
# Window_MenuPlayTime
#------------------------------------------------------------------------------
# Janela que exibe o tempo de jogo no menu.
#==============================================================================

class Window_MenuPlayTime < Window_PlayTime
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super
self.height = 80
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = MENU_TIME_WINDOW[2]
self.contents.font.size = $fontsize
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = system_color
self.contents.draw_text(0, 0, 120, 24, MENU_TIME_WINDOW[1], 1)
@total_sec = Graphics.frame_count / Graphics.frame_rate
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
text = sprintf("%02d:%02d:%02d", hour, min, sec)
self.contents.font.color = normal_color
self.contents.draw_text(0, 24, 120, 24, text, 1)
end
end

#==============================================================================
# Window_ShootStatus
#------------------------------------------------------------------------------
# Janela que exibe alguns status do personagem no menu.
#==============================================================================

class Window_ShootStatus < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0, 160, 216)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = MENU_STATUS_WINDOW[1]
self.contents.font.size = 20
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
return if $game_party.actors.size == 0
actor = $game_party.actors[0]
self.contents.font.color = system_color
# Desenho do nome do personagem
self.contents.draw_text(0, 0, 128, 20, actor.name, 1)
# Desenho do HP do personagem
draw_actor_hp(actor, 0, 20, 128)
# Desenho da arma equipada
self.contents.font.color = system_color
self.contents.draw_text(2, 40, 128, 20, "Arma Equipada", 1)
gun_image = ""
gun_name = ""
gun_bullets = [0, 0]
MENU_GUN_PROPERTIES.each do |key, value|
gun_image = value[0] if $game_switches[key]
gun_name = value[1] if $game_switches[key]
gun_bullets[0] = value[2] if $game_switches[key]
gun_bullets[1] = value[3] if $game_switches[key]
end
gun_image = MENU_GUN_PROPERTIES[0][0] if gun_image.empty?
gun_name = MENU_GUN_PROPERTIES[0][1] if gun_name.empty?
gun_bullets[0] = "" if gun_bullets[1] == 0
gun_bullets[1] = "" if gun_bullets[1] == 0
gun_bitmap = RPG::Cache.picture(gun_image)
gun_w, gun_h = gun_bitmap.width, gun_bitmap.height
self.contents.blt(0, 60, gun_bitmap, Rect.new(0, 0, gun_w, gun_h))
# Desenho do nome da arma
self.contents.draw_text(0, 60 + gun_h, 128, 24, gun_name, 1)
# Desenho do status do personagem
draw_actor_state(actor, 0, 80 + gun_h, 128)
end
#--------------------------------------------------------------------------
# Desenhar HP
# actor : Herói
# x : Desenhar a partir da coordenada x
# y : Desenhar a partir da coordenada y
# width : Desenhar comprimento
#--------------------------------------------------------------------------
def draw_actor_hp(actor, x, y, width = 144)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 32, 24, $data_system.words.hp)
if width - 32 >= 108
hp_x = x + width - 108
flag = true
elsif width - 32 >= 48
hp_x = x + width - 48
flag = false
end
self.contents.font.color = actor.hp == 0 ? knockout_color :
actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
self.contents.draw_text(hp_x, y, 48, 24, actor.hp.to_s, 2)
if flag
self.contents.font.color = normal_color
self.contents.draw_text(hp_x + 48, y, 12, 24, "/", 1)
self.contents.draw_text(hp_x + 60, y, 48, 24, actor.maxhp.to_s)
end
end
#--------------------------------------------------------------------------
# Desenhar status
# actor : Herói
# x : Desenhar a partir da coordenada x
# y : Desenhar a partir da coordenada y
# width : Desenhar o comprimento
#--------------------------------------------------------------------------
def draw_actor_state(actor, x, y, width = 120)
text = make_battler_state_text(actor, width, true)
self.contents.font.color = actor.hp == 0 ? knockout_color : normal_color
self.contents.draw_text(x, y, width, 24, text, 1)
end
end

#==============================================================================
# Window_MenuMapName
#------------------------------------------------------------------------------
# Janela que exibe o nome do mapa no menu.
#==============================================================================

class Window_MenuMapName < Window_Base
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0, 160, 56)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = MENU_MAP_WINDOW[1]
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = system_color
name = load_data("./Data/MapInfos.rxdata")[$game_map.map_id].name
self.contents.draw_text(0, 0, 128, 24, name, 1)
end
end

#==============================================================================
# Window_MenuHelp
#------------------------------------------------------------------------------
# Esta classe exibe uma janela de explicação para os itens do menu.
#==============================================================================

class Window_MenuHelp < Window_Help
#--------------------------------------------------------------------------
# Definição do Texto
# text : Texto exibido na janela
# align : Alinhamento (0 = esquerda, 1 = centralizado, 2 = direita)
#--------------------------------------------------------------------------
def set_text(text, align = 1)
if text != @text or align != @align
self.contents.clear
self.contents.font.color = normal_color
self.contents.draw_text(4, 0, self.width - 40, 24, text, align)
@text = text
@align = align
@actor = nil
end
self.visible = true
end
end

#==============================================================================
# Window_Item
#------------------------------------------------------------------------------
# Esta janela exibe os Itens possuídos na tela de Itens
#==============================================================================

class Window_Item < Window_Selectable
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
alias kpmst_initialize initialize
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
kpmst_initialize
if $scene.is_a?(Scene_Menu)
self.x = 160
self.y = 56
self.width = 480
self.height = 368
refresh
end
end
#--------------------------------------------------------------------------
# Desenhar Item
#
# index : índice de Itens
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
case item
when RPG::Item
number = $game_party.item_number(item.id)
when RPG::Weapon
number = $game_party.weapon_number(item.id)
when RPG::Armor
number = $game_party.armor_number(item.id)
end
if item.is_a?(RPG::Item) and $game_party.item_can_use?(item.id)
self.contents.font.color = normal_color
else
self.contents.font.color = disabled_color
end
x = 4 + index % 2 * (288 + 32)
x = 4 + index % 2 * (208 + 32) if $scene.is_a?(Scene_Menu)
y = index / 2 * 32
rect = Rect.new(x, y, self.width / @column_max - 32, 24)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
bitmap = RPG::Cache.icon(item.icon_name)
opacity = self.contents.font.color == normal_color ? 255 : 128
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
if $scene.is_a?(Scene_Menu)
self.contents.font.name = "Calibri"
self.contents.draw_text(x + 28, y, 136, 32, item.name, 0)
self.contents.draw_text(x + 152, y, 16, 32, ":", 1)
self.contents.draw_text(x + 168, y, 24, 32, number.to_s, 2)
else
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
end
end
end

#==============================================================================
# Window_ItemCommand
#------------------------------------------------------------------------------
# Janela de seleção de escolha de itens.
#==============================================================================

class Window_ItemCommand < Window_Selectable
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super(0, 0, 480, 56)
self.contents = Bitmap.new(width - 32, height - 32)
@column_max = 3
@item_max = 3
self.contents.font.name = MENU_ITEM_COMMAND_WINDOW[1]
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.draw_text( 4, 0, 117, 24, "Utilizar", 1)
self.contents.draw_text(165, 0, 117, 24, "Descartar", 1)
self.contents.draw_text(326, 0, 117, 24, "Retornar", 1)
end
#--------------------------------------------------------------------------
# Aquisição de uma linha superior
#--------------------------------------------------------------------------
def top_row
return self.oy / 24
end
#--------------------------------------------------------------------------
# Definição da linha superior
# row : Linha do Cabeçalho
#--------------------------------------------------------------------------
def top_row=(row)
row = 0 if row < 0
row = row_max - 1 if row > row_max - 1
self.oy = row * 24
end
#--------------------------------------------------------------------------
# Definição do número de linhas que podem ser mostradas em uma página
#--------------------------------------------------------------------------
def page_row_max
return (self.height - 32) / 24
end
#--------------------------------------------------------------------------
# Atualização do cursor
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
return
end
row = @index / @column_max
if row < self.top_row
self.top_row = row
end
if row > self.top_row + (self.page_row_max - 1)
self.top_row = row - (self.page_row_max - 1)
end
cursor_width = self.width / @column_max - 32
x = @index % @column_max * (cursor_width + 32)
y = @index / @column_max * 24 - self.oy
self.cursor_rect.set(x, y, cursor_width, 24)
end
end

#==============================================================================
# Window_Choice
#------------------------------------------------------------------------------
# Janela de seleção básica.
#==============================================================================

class Window_Choice < Window_Selectable
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# text : Texto da janela
# answer1 : Resposta 1
# answer2 : Resposta 2
#--------------------------------------------------------------------------
def initialize(text, answer1, answer2)
@text = text
@answer1 = answer1
@answer2 = answer2
super(0, 0, 56, 104)
create_contents
self.index = 0
self.active = false
self.visible = false
@item_max = 2
end
#--------------------------------------------------------------------------
# Criação do conteúdo
#--------------------------------------------------------------------------
def create_contents
bitmap = Bitmap.new(1, 1)
bitmap.font.name = MENU_CHOICE_WINDOW[0]
w1 = bitmap.text_size(@text).width
w2 = bitmap.text_size(@answer1).width
w3 = bitmap.text_size(@answer2).width
width = [w1, w2, w3].sort.reverse[0] + 32
width = 56 if width < 56
bitmap.dispose
self.width = width + 32
self.contents = Bitmap.new(self.width - 32, 72)
self.contents.font.name = MENU_CHOICE_WINDOW[0]
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = system_color
self.contents.draw_text(0, 0, self.contents.width, 24, @text, 1)
self.contents.font.color = normal_color
self.contents.draw_text(0, 24, self.contents.width, 24, @answer1, 1)
self.contents.draw_text(0, 48, self.contents.width, 24, @answer2, 1)
end
#--------------------------------------------------------------------------
# Atualização do retângulo do cursor
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
elsif @index >= 0
self.cursor_rect.set(0, @index * 24 + 24, self.contents.width, 24)
end
end
#--------------------------------------------------------------------------
# Definição do texto da janela
# text : Texto da janela
#--------------------------------------------------------------------------
def set_text(text)
@text = text
create_contents
end
end

#==============================================================================
# Window_EquipItem
#------------------------------------------------------------------------------
# Esta é a janela que mostra as escolhas ao se trocar de equipamento.
#==============================================================================

class Window_MenuEquipItem < Window_EquipItem

#--------------------------------------------------------------------------
# Inicialização dos Objeto
#
# actor : Herói
# equip_type : Tipo de Equipamento (0-3)
#--------------------------------------------------------------------------
def initialize(actor, equip_type)
super(actor, equip_type)
self.x = 160
self.y = 56
self.width = 480
self.height = 368
refresh
end
#--------------------------------------------------------------------------
# Desenhar itens
# index : Index do item
#--------------------------------------------------------------------------
def draw_item(index)
item = @data[index]
x = 4 + index % 2 * (208 + 32)
y = index / 2 * 32
case item
when RPG::Weapon
number = $game_party.weapon_number(item.id)
when RPG::Armor
number = $game_party.armor_number(item.id)
end
bitmap = RPG::Cache.icon(item.icon_name)
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
self.contents.font.color = normal_color
self.contents.font.name = "Calibri"
self.contents.draw_text(x + 28, y, 136, 32, item.name, 0)
self.contents.draw_text(x + 152, y, 16, 32, ":", 1)
self.contents.draw_text(x + 168, y, 24, 32, number.to_s, 2)
end
end

#==============================================================================
# Window_EquipCommand
#------------------------------------------------------------------------------
# Janela de seleção de escolha de equipamentos.
#==============================================================================

class Window_EquipCommand < Window_ItemCommand
#--------------------------------------------------------------------------
# Inclusão das constantes e métodos do módulo Shoot_SystemSettings
#--------------------------------------------------------------------------
include Shoot_SystemSettings
#--------------------------------------------------------------------------
# Inicialização do objeto
#--------------------------------------------------------------------------
def initialize
super
self.contents = Bitmap.new(width - 32, height - 32)
@column_max = 3
@item_max = 3
self.contents.font.name = MENU_EQUIP_COMMAND_WINDOW[1]
refresh
end
#--------------------------------------------------------------------------
# Atualização
#--------------------------------------------------------------------------
def refresh
self.contents.draw_text( 4, 0, 117, 24, "Armas", 1)
self.contents.draw_text(165, 0, 117, 24, "Roupas", 1)
self.contents.draw_text(326, 0, 117, 24, "Retornar", 1)
end
end

[close]

Ele usa umas imagens para as armas, então se der erro, só colocar qualquer imagem com o nome pra testar.
Desde já, agradeço!!

[XP] Mapa no Menu

BillyKharles

21/02/2023 às 21:45