Problema com a resolução

Zombie · 26/06/2020 às 23:18

Estou usando um plugin de fullscreen e um de menu por imagens, mas ao ativar o full screen todas as imagens ficam no canto superior, e não sei muito bem o que alterar ou que coordenadas colocar para ajeitar isso nos eventos ou script.

Spoiler

[close]

O script de full screen que estou usando:

Spoiler

#=============================================================================
# Σ Fullscreen
#-----------------------------------------------------------------------------
# @author  : Gabriel "Gab!" Teles
# @date    : 2014-09-27
# @version : 0.9.2
#-----------------------------------------------------------------------------
# TODO:
#   - Transições por imagens
#-----------------------------------------------------------------------------
# Créditos:
#   Scripter Desconhecido no Pastebin (http://pastebin.com/sM2MNJZj)
#   Esrever : Map viewport/scroll fix
#   Zeus81  : FPS Display
#-----------------------------------------------------------------------------
# Permite utilizar fullscreen real (sem redimensionamento de tela), e alterar
# o limite da função Graphics.resize_screen para a resolução máxima do monitor
# ou um valor próximo.
#=============================================================================

# Módulo Graphics
class << Graphics
  # API
  User32   = DL.dlopen('user32')
  Kernel32 = DL.dlopen('kernel32')
  GetActiveWindow  = DL::CFunc.new(  User32['GetActiveWindow' ], DL::TYPE_LONG)
  GetSystemMetrics = DL::CFunc.new(  User32['GetSystemMetrics'], DL::TYPE_LONG)
  GetWindowRect    = DL::CFunc.new(  User32['GetWindowRect'   ], DL::TYPE_LONG)
  SetWindowLong    = DL::CFunc.new(  User32['SetWindowLong'   ], DL::TYPE_LONG)
  SetWindowPos     = DL::CFunc.new(  User32['SetWindowPos'    ], DL::TYPE_LONG)
  GetModuleHandle  = DL::CFunc.new(Kernel32['GetModuleHandle' ], DL::TYPE_LONG) 
 
  # DLL sendo utilizada
  _DLLName = DL::CPtr.malloc(140)
  s = DL::CFunc.new(Kernel32['GetPrivateProfileString'], DL::TYPE_LONG).call([
    DL::CPtr["Game"].to_i,
    DL::CPtr["Library"].to_i,
    0,
    _DLLName.to_i,
    140,
    DL::CPtr["./Game.ini"].to_i
  ])
 
  @@DLLName = File.basename(_DLLName.to_s(s))
 
  # Verifica se é uma RGSS3xx.dll
  if @@DLLName.match(/^RGSS3(\d{2})\.dll$/)
    @@DLLVersion = $1.to_i
   
    # Verifica se a versão é 0 ou 1.
    if @@DLLVersion.between?(0, 1)
      # Flag de fullscreen
      @@inFullscreen = false
     
      # Instância da DLL. *Necessariamente* a RGSS300.dll ou RGSS301.dll, visto
      # que o trabalho com memória a seguir é específico.
     
      @@DLLHandle   = GetModuleHandle.call([DL::CPtr[@@DLLName].to_i])
     
      # Instância da janela de jogo
      @@hWnd       = GetActiveWindow.call([])
     
      # Tamanho da tela
      @@screenSize = [
        GetSystemMetrics.call([0]),
        GetSystemMetrics.call([1])
      ]
     
      # Calcula o próximo tamanho divisível por 32 para fazer a limitação
      width, height = @@screenSize
      width  += (32 - (width  % 32)) unless (width  % 32).zero?
      height += (32 - (height % 32)) unless (height % 32).zero?
      puts "Limitando para: #{width}x#{height}" if $TEST
     
      #-----------------------------------------------------------------------
      # Bruxaria de scripter desconhecido. Remove a limitação de tamanho para
      # o método Graphics.resize_screen (640x480)
      #
      # Base retirada de: http://pastebin.com/sM2MNJZj
      #
      # Adaptações para a RGSS300.dll e início do mapeamento dos endereços
      # utilizados por Gab!
      #-----------------------------------------------------------------------
     
      # Número para string
      wh = ->(w, h, off = 0){
        [w + off, h + off].pack('l2').scan(/..../)
      }
     
      # Altera um valor na memória relativa à DLL
      mod = ->(adr, val){
        adr += @@OFF if @@DLLVersion.zero?
        DL::CPtr.new(@@DLLHandle + adr)[0, val.size] = val
      }
     
      # Valores úteis
      wt,  ht  = width.divmod(32), height.divmod(32)
      w,   h   = wh.(width, height)
      ww,  hh  = wh.(width, height, 32)
      www, hhh = wh.(wt.first, ht.first, 1)
      zero     = [0].pack('l')
         
      # Faz as alterações na memória
     
      # Graphics
      @@OFF = 0
      mod.(0x195F, "\x90"*5) # ???
      mod.(0x19A4,   h     ) # ???
      mod.(0x19A9,   w     ) # ???
      mod.(0x1A56,   h     ) # ???
      mod.(0x1A5B,   w     ) # ???
      mod.(0x20F6,   w     ) # Max width  (?)
      mod.(0x20FF,   w     ) # Max width  (?)
      mod.(0x2106,   h     ) # Max height (?)
      mod.(0x210F,   h     ) # Max height (?)
     
      # Plane (?) Class
      @@OFF   = -0xC0
      Graphics::PlaneSpeedUp = true
        # Setando para false não é necessário reescrever classe Plane. No
        # entanto, o mapa fica MUITO lento.
      mod.(0x1C5E3,  Graphics::PlaneSpeedUp ? zero : h) # Max height
      mod.(0x1C5E8,  Graphics::PlaneSpeedUp ? zero : w) # Max width
     
      # ???
      @@OFF = 0x20
      mod.(0x1F477,  h     ) # ???
      mod.(0x1F47C,  w     ) # ???
     
      # Tilemap Class
      @@OFF = 0x1E0
      mod.(0x211FF,  hh    ) # Tilemap render height
      mod.(0x21204,  ww    ) # Tilemap render width
      mod.(0x21D7D,  hhh[0]) # Tilemap max tiles on screen height
      mod.(0x21E01,  www[0]) # Tilemap max tiles on screen width
     
      # ???
      @@OFF = 0x140
      mod.(0x10DEA8, h     ) # ???
      mod.(0x10DEAD, w     ) # ???     
      mod.(0x10DEDF, h     ) # ???
      mod.(0x10DEE3, w     ) # ???
      mod.(0x10DF14, h     ) # ???
      mod.(0x10DF18, w     ) # ???
      mod.(0x10DF48, h     ) # ???
      mod.(0x10DF4C, w     ) # ???
      mod.(0x10E6A7, w     ) # ???
      mod.(0x10E6C3, h     ) # ???
      mod.(0x10EEA9, w     ) # ???
      mod.(0x10EEB9, h     ) # ???
     
      #-------------------------------------------------------------------------
      # Fim da bruxaria
      #-------------------------------------------------------------------------
     
      # Sprite de transição de tela
      @@TransitionSprite = Sprite.new
      @@TransitionSprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)
      @@TransitionSprite.bitmap.fill_rect(@@TransitionSprite.bitmap.rect, Color.new(0, 0, 0))
      @@TransitionSprite.opacity = 0
      @@TransitionSprite.z = 0x7FFFFFFF
     
      # Bitmap da tela no momento do Graphics.freeze
      @@FrozenBitmap = Bitmap.new(Graphics.width, Graphics.height)
      @@FrozenBitmap.fill_rect(@@FrozenBitmap.rect, Color.new(0, 0, 0))
     
      # Realiza a transição de tela
      # Nota: Não é possível realizar transição de tela com imagens
      alias oldFullscreenResTransition transition
      def transition(time, image='', vague=40)
        @@TransitionSprite.bitmap.dispose
        @@TransitionSprite.dispose
        @@TransitionSprite = Sprite.new
        @@TransitionSprite.bitmap = @@FrozenBitmap
        @@TransitionSprite.opacity = 255
        @@TransitionSprite.z = 0x7FFFFFFF
     
        oldFullscreenResTransition(0)
       
        dec = (255.0 / time)
        time.times {
          @@TransitionSprite.opacity -= dec
          Graphics.update
        }
      end
     
      # Fadein
      def fadein(time)
        @@FrozenBitmap = Bitmap.new(Graphics.width, Graphics.height)
        @@FrozenBitmap.fill_rect(@@FrozenBitmap.rect, Color.new(0, 0, 0))
       
        transition(time)
      end
     
      # Fadeout
      def fadeout(time)
        inc = (255.0 / time)
        time.times {
          @@TransitionSprite.opacity += inc
          Graphics.update
        }
      end
     
      # Armazena a imagem da tela
      alias oldFullscreenResFreeze freeze
      def freeze(*a, &b)
        oldFullscreenResFreeze(*a, &b)
        @@FrozenBitmap = Graphics.snap_to_bitmap
      end
     
      # Realiza o redimensionamento de tela
      alias gabFullscreenOldResizeScreen resize_screen
      def resize_screen(*a, &b)
        # Redimensiona normalmente
        gabFullscreenOldResizeScreen(*a, &b)
        # Redimensiona o sprite de transição
        @@TransitionSprite.bitmap.dispose
        @@TransitionSprite.bitmap = Bitmap.new(*Graphics.size)
        @@TransitionSprite.bitmap.fill_rect(@@TransitionSprite.bitmap.rect, Color.new(0, 0, 0))
       
        if Graphics::PlaneSpeedUp
          # Manda o sinal de atualização para todas as instâncias da classe Plane
          ObjectSpace.each_object(Plane){|plane|
            plane.send(:recreateBitmap)
          }
        end
      end
     
      # Altera para fullscreen
      def fullscreen
        # Retorna se já estiver em fullscreen
        return if @@inFullscreen
        # Tamanho antes do fullscreen
        rect = DL::CPtr.malloc(16)
        rect[0, 16] = 0.chr * 16
        GetWindowRect.call([@@hWnd, rect])
        @@windowSize = rect[0, 16].unpack("l*")
        @@windowSize[2] -= @@windowSize[0]
        @@windowSize[3] -= @@windowSize[1]
        @@windowResolution = Graphics.size
        # Muda o tamanho da tela
        Graphics.resize_screen(*@@screenSize)
        # Remover bordas da janela
        SetWindowLong.call([@@hWnd, -16, 0x14000000])
        # Coloca a janela acima de todas as outras
        SetWindowPos.call([@@hWnd, -1, 0, 0, *@@screenSize, 0])
        # Modifica a flag de fullscreen
        @@inFullscreen = true
        # Espera alguns frames para terminar o processamento
        Graphics.wait(5)
      end
     
      # Altera para modo janela
      def windowed
        # Retorna se não estiver em fullscreen
        return unless @@inFullscreen
        # Muda o tamanho da tela
        Graphics.resize_screen(*@@windowResolution)
        # Recoloca bordas da janela
        SetWindowLong.call([@@hWnd, -16, 0x14CA0000])
        # Coloca a janela na posição x,y,z comum e ajusta seu tamanho
        SetWindowPos.call([@@hWnd, 0, *@@windowSize, 0])
        # Modifica a flag de fullscreen
        @@inFullscreen = false
        # Espera alguns frames para terminar o processamento
        Graphics.wait(5)
      end
     
      # Tamanho da tela
      def size
        [self.width, self.height]
      end
     
      # Verifica se a janela está no modo fullscreen
      def fullscreen?
        return @@inFullscreen
      end
     
      # Verifica se a janela está no modo janela
      def windowed?
        return !@@inFullscreen
      end
     
      # Alterna entre os modos fullscreen e janela
      def toggleFullscreen
        @@inFullscreen ? self.windowed : self.fullscreen
      end
    end
  end
end

if Graphics::PlaneSpeedUp
  # Remove a classe Plane Anterior
  Object.send(:remove_const, :Plane)
  # Redefinição da classe Plane
  class Plane
    attr_reader :viewport
    attr_reader :bitmap
    attr_reader :ox
    attr_reader :oy
    attr_reader :opacity
    attr_reader :blend_type
    attr_reader :color
    attr_reader :tone
    attr_reader :visible
    attr_reader :zoom_x
    attr_reader :zoom_y
    attr_reader :z
   
    # Inicialização do objeto
    def initialize(viewport = nil)
      # É necessário verificar se um viewport foi enviado. Desse modo, ao mudar a
      # resolução da tela, deve-se mudar também a rect do viewport para que o
      # Plane que ocupava a tela toda continue
      @defaultViewport = !viewport.is_a?(Viewport)
      @viewport = @defaultViewport ? Viewport.new(0, 0, *Graphics.size) : viewport
     
      @sprite        = Sprite.new(@viewport)
      @bitmap        = nil
      @ox            = @sprite.ox         # 0
      @oy            = @sprite.oy         # 0
      @opacity       = @sprite.opacity    # 255
      @blend_type    = @sprite.blend_type # 0
      @color         = @sprite.color      # Color.new(0, 0, 0, 0)
      @tone          = @sprite.tone       # Tone.new(0, 0, 0, 0)
      @visible       = @sprite.visible    # true
      @z             = @sprite.z          # 0
      @zoom_x        = @sprite.zoom_x     # 1.0
      @zoom_y        = @sprite.zoom_y     # 1.0
    end
   
    def bitmap=(bitmap)
      return unless bitmap.is_a?(Bitmap)
      @bitmap = bitmap
      self.recreateBitmap(true)
    end
   
    def ox=(value)
      @ox = value
      return unless @bitmap
      @sprite.ox = (value % @bitmap.width)
    end
   
    def oy=(value)
      @oy = value
      return unless @bitmap
      @sprite.oy = (value % @bitmap.height)
    end
   
    def opacity=(value)
      @sprite.opacity = value
      @opacity = @sprite.opacity
    end
   
    def blend_type=(value)
      @sprite.blend_type = value
      @blend_type = @sprite.blend_type
    end
   
    def color=(value)
      @sprite.color = value
      @color = @sprite.color
    end
   
    def tone=(value)
      @sprite.tone = value
      @tone = @sprite.tone
    end
   
    def viewport=(value)
      @defaultViewport &= (value == @sprite.viewport)
      @sprite.viewport = value
      @viewport = @sprite.viewport
    end
   
    def visible=(value)
      @sprite.visible = value
      @visible = sprite.visible
    end
   
    def z=(value)
      @sprite.z = value
      @z = @sprite.z
    end
   
    def zoom_x=(value)
      @sprite.zoom_x = value
      @zoom_x = @sprite.zoom_x
      self.recreateBitmap
    end
   
    def zoom_y=(value)
      @sprite.zoom_y = value
      @zoom_y = @sprite.zoom_y
      self.recreateBitmap
    end
   
    def disposed?
      return @sprite.disposed?
    end
   
    def dispose
      @sprite.dispose
    end
   
    protected
   
    def recreateBitmap(forceRefresh = false)
      cw, ch      = Graphics.width * (2.0/@zoom_x), Graphics.height * (2.0/@zoom_y)
      needRefresh = true
     
      if @defaultViewport
        @viewport.rect.width, @viewport.rect.height = *Graphics.size
      end
     
      if @sprite.bitmap.nil? or @sprite.bitmap.disposed?
        newBitmap = Bitmap.new(cw, ch)
      else
        if (cw == @sprite.bitmap.width) and (ch == @sprite.bitmap.height) and (!forceRefresh)
          return
        end
       
        newBitmap = Bitmap.new(cw, ch)
        if (cw < @sprite.bitmap.width) and (ch < @sprite.bitmap.height)
          newBitmap.blt(0, 0, @sprite.bitmap, @sprite.bitmap.rect)
          @sprite.bitmap.dispose
          needRefresh = false
        end
      end
     
      @sprite.bitmap = newBitmap
      self.refreshBitmap if needRefresh or forceRefresh
    end
   
    def refreshBitmap
      # Limpa o bitmap
      b = @sprite.bitmap
      b.clear
     
      return if @bitmap.nil?
     
      # Quantia de espaços para blt
      tx = (b.width  / @bitmap.width.to_f )
      ty = (b.height / @bitmap.height.to_f)
     
      b.blt(0, 0, @bitmap, @bitmap.rect)
     
      return if tx + ty == 2
     
      # Preenche 1 linha
      basePow = @bitmap.width
      baseRct = Rect.new(0, 0, @bitmap.width, @bitmap.height)
     
      Math.log2(tx).floor.times{
        b.blt(basePow, 0, b, baseRct)
        baseRct.width += basePow
        basePow *= 2
      }
     
      # Último bitmap da linha
      baseRct.width = (b.width - baseRct.width)
      b.blt(basePow, 0, b, baseRct)
     
      # Preenche o restante das linhas
      basePow = @bitmap.height
      baseRct = Rect.new(0, 0, b.width, @bitmap.height)
     
      Math.log2(ty).floor.times{
        b.blt(0, basePow, b, baseRct)
        baseRct.height += basePow
        basePow *= 2
      }
     
      # Última linha
      baseRct.height = b.height - baseRct.height
      b.blt(basePow, 0, b, baseRct)
    end
  end
end

class Game_Map
  # Número de tiles horizontais na tela
  def screen_tile_x
    (Graphics.width / 32.0).ceil
  end
 
  # Número de tiles verticais na tela
  def screen_tile_y
    (Graphics.height / 32.0).ceil
  end
end

# Contador de FPS para o modo Fullscreen
if $TEST
  # FPS Display // Zeus81
  # http://forums.rpgmakerweb.com/index.php?/topic/3738-fps-display-isnt-very-accurate/#entry40350
  module Graphics
    @fps, @fps_tmp = 0, []
   
    class << self
      attr_reader :fps
     
      alias fps_update update unless method_defined?(:fps_update)
      def update
        t = Time.now
        fps_update
        @fps_tmp[frame_count % frame_rate] = Time.now != t
        @fps = 0
        frame_rate.times {|i| @fps += 1 if @fps_tmp[i]}
        fps_sprite.src_rect.y = @fps * 16
      end
     
      def fps_sprite
        if !@fps_sprite or @fps_sprite.disposed?
          @fps_sprite = Sprite.new
          @fps_sprite.z = 0x7FFFFFFF
          @fps_sprite.bitmap = Bitmap.new(24, 16*120)
          @fps_sprite.bitmap.font.name = "Arial"
          @fps_sprite.bitmap.font.size = 16
          @fps_sprite.bitmap.font.color.set(255, 255, 255)
          @fps_sprite.bitmap.fill_rect(@fps_sprite.bitmap.rect, Color.new(0, 0, 0, 127))
          120.times {|i|
            @fps_sprite.bitmap.draw_text(0, i*16, 24, 16, "% 3d"%i, 1)
          }
          @fps_sprite.src_rect.height = 16
        end
        return @fps_sprite
      end     
    end
  end
end

#==============================================================================
# ▼ Viewports/Map Fix for Modified RGSS300.dll File
#   Origin of Code: Yanfly Engine Ace - Ace Core Engine v1.06
# -- Last Updated: 2011.12.26
# -- Level: Easy, Normal
# -- Requires: n/a
#==============================================================================
 
#==============================================================================
# ■ Game_Map
#==============================================================================
 
class Game_Map
 
  #--------------------------------------------------------------------------
  # overwrite method: scroll_down
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    if loop_vertical?
      @display_y += distance
      @display_y %= @map.height * 256
      @parallax_y += distance
    else
      last_y = @display_y
      dh = Graphics.height > height * 32 ? height : screen_tile_y
      @display_y = [@display_y + distance, height - dh].min
      @parallax_y += @display_y - last_y
    end
  end
 
  #--------------------------------------------------------------------------
  # overwrite method: scroll_right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    if loop_horizontal?
      @display_x += distance
      @display_x %= @map.width * 256
      @parallax_x += distance
    else
      last_x = @display_x
      dw = Graphics.width > width * 32 ? width : screen_tile_x
      @display_x = [@display_x + distance, width - dw].min
      @parallax_x += @display_x - last_x
    end
  end
 
end # Game_Map
 
#==============================================================================
# ■ Spriteset_Map
#==============================================================================
 
class Spriteset_Map
 
  #--------------------------------------------------------------------------
  # overwrite method: create_viewports
  #--------------------------------------------------------------------------
  def create_viewports
    if Graphics.width > $game_map.width * 32 && !$game_map.loop_horizontal?
      dx = (Graphics.width - $game_map.width * 32) / 2
    else
      dx = 0
    end
    dw = [Graphics.width, $game_map.width * 32].min
    dw = Graphics.width if $game_map.loop_horizontal?
    if Graphics.height > $game_map.height * 32 && !$game_map.loop_vertical?
      dy = (Graphics.height - $game_map.height * 32) / 2
    else
      dy = 0
    end
    dh = [Graphics.height, $game_map.height * 32].min
    dh = Graphics.height if $game_map.loop_vertical?
    @viewport1 = Viewport.new(dx, dy, dw, dh)
    @viewport2 = Viewport.new(dx, dy, dw, dh)
    @viewport3 = Viewport.new(dx, dy, dw, dh)
    @viewport2.z = 50
    @viewport3.z = 100
  end
 
  #--------------------------------------------------------------------------
  # new method: update_viewport_sizes
  #--------------------------------------------------------------------------
  def update_viewport_sizes
    if Graphics.width > $game_map.width * 32 && !$game_map.loop_horizontal?
      dx = (Graphics.width - $game_map.width * 32) / 2
    else
      dx = 0
    end
    dw = [Graphics.width, $game_map.width * 32].min
    dw = Graphics.width if $game_map.loop_horizontal?
    if Graphics.height > $game_map.height * 32 && !$game_map.loop_vertical?
      dy = (Graphics.height - $game_map.height * 32) / 2
    else
      dy = 0
    end
    dh = [Graphics.height, $game_map.height * 32].min
    dh = Graphics.height if $game_map.loop_vertical?
    rect = Rect.new(dx, dy, dw, dh)
    for viewport in [@viewport1, @viewport2, @viewport3]
      viewport.rect = rect
    end
  end
 
end # Spriteset_Map
 
#==============================================================================
# ■ Scene_Map
#==============================================================================
 
class Scene_Map < Scene_Base
 
  #--------------------------------------------------------------------------
  # alias method: post_transfer
  #--------------------------------------------------------------------------
  alias scene_map_post_transfer_ace post_transfer
  def post_transfer
    @spriteset.update_viewport_sizes
    scene_map_post_transfer_ace
  end
 
end # Scene_Map
 
#==============================================================================
# ■ Game_Event
#==============================================================================
 
class Game_Event < Game_Character
 
  #--------------------------------------------------------------------------
  # overwrite method: near_the_screen?
  #--------------------------------------------------------------------------
  def near_the_screen?(dx = nil, dy = nil)
    dx = [Graphics.width, $game_map.width * 256].min/32 - 5 if dx.nil?
    dy = [Graphics.height, $game_map.height * 256].min/32 - 5 if dy.nil?
    ax = $game_map.adjust_x(@real_x) - Graphics.width / 2 / 32
    ay = $game_map.adjust_y(@real_y) - Graphics.height / 2 / 32
    ax >= -dx && ax <= dx && ay >= -dy && ay <= dy
  end
 
end # Game_Event

# Chama o método que realiza a mudança de tamanho
# Graphics.fullscreen
Graphics.resize_screen(1632, 832)

__END__
# TESTES
# Graphics.windowed
x = Bitmap.new(50, 50)
x.gradient_fill_rect(0,  0, 50, 25, Color.new(255, 0, 0), Color.new(0, 255, 0))
x.gradient_fill_rect(0, 25, 50, 25, Color.new(0, 255, 0), Color.new(0, 0, 255))
y = Plane.new
y.bitmap = x
y.zoom_x = 3
y.zoom_y = 3
#Graphics.fullscreen
#Graphics.windowed
loop do
  Graphics.update
  y.ox += 1
  y.oy += 1
end

[close]

Do menu:

Spoiler

#==============================================================================
# ** MAYA - Mouse Title Screen
#------------------------------------------------------------------------------
# Autor: Takkun (a.k.a Faalco)
# Create: 14/06/2018
# Version: 1.0a
#==============================================================================
# * Instructions & Info:
# -----------------------------------------------------------------------------
# Paste the script above the main of your project, and make the necessary
# settings. This script requires the Jet Mouse to VX Ace to place it above
# this script to avoid incompatibilities.
#
# This script (Only the MAYA - Mouse Title Screen) can be used for commercial
# and non-commercial purposes, credits are welcome but not required.
#
# Jet Mouse for VX Ace was created by the same then all credits are to it.
#
# Any problems before the script can be taken on the topics of the same or by
# personal message us forums in which I participate.
#
#==============================================================================
($imported ||= {})["MAYA - Mouse Title Screen"] = true
#==============================================================================
# ** MAYA Module
#------------------------------------------------------------------------------
# All the settings of this script can be made in this module.
#==============================================================================
module MAYA
#--------------------------------------------------------------------------
# * Logotipe Image (System Folder).
#--------------------------------------------------------------------------
Logotipe = "Logo"
#--------------------------------------------------------------------------
# * Logotipe Position.
#--------------------------------------------------------------------------
Logotipe_Position = [000, 000] # X, Y
#--------------------------------------------------------------------------
# * Menu Buttons Images (System Folder).
#--------------------------------------------------------------------------
MenuButtons = ["NewGame", "Continue", "Exit"]
#--------------------------------------------------------------------------
# * Menu Buttons X Position.
#--------------------------------------------------------------------------
MenuButtonsX = [229, 236, 257]
#--------------------------------------------------------------------------
# * Menu Buttons Y Position.
#--------------------------------------------------------------------------
MenuButtonsY = [289, 313, 337]
#--------------------------------------------------------------------------
# * Menu Buttons OFF Opacity.
#--------------------------------------------------------------------------
MenuButtons_OFF = 100
end
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
# This class performs the title screen processing.
#==============================================================================

class Scene_Title < Scene_Base
#--------------------------------------------------------------------------
# * Start Processing
#--------------------------------------------------------------------------
def start
super
SceneManager.clear
Graphics.freeze
create_logotipe
create_background
create_button_menu
play_title_music
end
#--------------------------------------------------------------------------
# * Get Transition Speed
#--------------------------------------------------------------------------
def transition_speed
return 20
end
#--------------------------------------------------------------------------
# * Termination Processing
#--------------------------------------------------------------------------
def terminate
super
SceneManager.snapshot_for_background
dispose_all_images
end
#--------------------------------------------------------------------------
# * Dispose All Images
#--------------------------------------------------------------------------
def dispose_all_images
@sprite1.bitmap.dispose
@sprite1.dispose
@logotipe.dispose
@op1.dispose
@op2.dispose
@op3.dispose
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
update_basic
end
#--------------------------------------------------------------------------
# * Update Frame (Basic)
#--------------------------------------------------------------------------
def update_basic
Graphics.update
Input.update
update_menu_buttons
update_all_windows
end
#--------------------------------------------------------------------------
# * Create Background
#--------------------------------------------------------------------------
def create_background
@sprite1 = Sprite.new
@sprite1.bitmap = Cache.title1($data_system.title1_name)
center_sprite(@sprite1)
end
#--------------------------------------------------------------------------
# * Create Logotipe
#--------------------------------------------------------------------------
def create_logotipe
@logotipe = Sprite.new
@logotipe.bitmap = Cache.system(MAYA::Logotipe)
@logotipe.x = MAYA::Logotipe_Position[0]
@logotipe.y = MAYA::Logotipe_Position[1]
@logotipe.z = 300
end
#--------------------------------------------------------------------------
# * Create Logotipe
#--------------------------------------------------------------------------
def create_button_menu
# Create Title Images
@op1 = Sprite.new
@op2 = Sprite.new
@op3 = Sprite.new
# Bitmap Images
@op1.bitmap = Cache.system(MAYA::MenuButtons[0])
@op2.bitmap = Cache.system(MAYA::MenuButtons[1])
@op3.bitmap = Cache.system(MAYA::MenuButtons[2])
# Position X
@op1.x = MAYA::MenuButtonsX[0]
@op2.x = MAYA::MenuButtonsX[1]
@op3.x = MAYA::MenuButtonsX[2]
# Position Y
@op1.y = MAYA::MenuButtonsY[0]
@op2.y = MAYA::MenuButtonsY[1]
@op3.y = MAYA::MenuButtonsY[2]
# Position Z
@op1.z = @op2.z = @op3.z = 300
# Opacity
@op1.opacity = @op2.opacity = @op3.opacity = MAYA::MenuButtons_OFF
end
#--------------------------------------------------------------------------
# * Update Menu Buttons
#--------------------------------------------------------------------------
def update_menu_buttons
# New Game
if Mouse.area?(@op1.x, @op1.y, @op1.width, @op1.height)
on_sprite(@op1)
if Mouse.press?(1)
DataManager.setup_new_game
fadeout_all
$game_map.autoplay
SceneManager.goto(Scene_Map)
end
else
off_sprite(@op1)
end
# Continue
if Mouse.area?(@op2.x, @op2.y, @op2.width, @op2.height)
on_sprite(@op2)
if Mouse.press?(1)
SceneManager.call(creation(12))
end
else
off_sprite(@op2)
end
# Exit
if Mouse.area?(@op3.x, @op3.y, @op3.width, @op3.height)
on_sprite(@op3)
if Mouse.press?(1)
fadeout_all
SceneManager.exit
end
else
off_sprite(@op3)
end
end
#--------------------------------------------------------------------------
# * Move Sprite to Screen Center
#--------------------------------------------------------------------------
def center_sprite(sprite)
sprite.ox = sprite.bitmap.width / 2
sprite.oy = sprite.bitmap.height / 2
sprite.x = Graphics.width / 2
sprite.y = Graphics.height / 2
end
#--------------------------------------------------------------------------
# * Play Title Screen Music
#--------------------------------------------------------------------------
def play_title_music
$data_system.title_bgm.play
RPG::BGS.stop
RPG::ME.stop
end
#--------------------------------------------------------------------------
# * On Sprite
#--------------------------------------------------------------------------
def on_sprite(sprite)
if sprite.opacity < 255
sprite.opacity += 6
end
end
#--------------------------------------------------------------------------
# * Off Sprite
#--------------------------------------------------------------------------
def off_sprite(sprite)
if sprite.opacity > 100
sprite.opacity -= 6
end
end
end

[close]

Gabriel · 27/06/2020 às 21:36

Poxa, o script de menu que você passou ainda requeria um outro script de mouse pra funcionar. Tive que procurar aqui pra conseguir te ajudar. Na próxima, se puder, coloca pelo menos os links dos scripts que estiver usando, já ajuda pakas. Enfim, vamos lá. ;D

Na verdade, não há nenhum problema. Você está usando um script que aumenta a resolução da tela do jogo e é isso que ele está fazendo.

Código: linha 676 do script de Fullscreen

Graphics.resize_screen(1632, 832)

Com esse script de Fullscreen as dimensões da tela do jogo são mudadas do padrão 544 x 416 para 1632 x 832. O que está acontecendo é que você está tentando usar uma imagem de apenas 544 x 416 na nova resolução. O resultado é esse, a imagem não ocupa a tela toda e, como por padrão as coordenadas dela são 0, ela fica posicionada no canto superior esquerdo da tela.

Existem três opções que você pode escolher para resolver isso:

1- Mudar as dimensões das imagens que está usando para as da resolução que o script define.
2 - Remover a linha que elenquei logo acima do código de Fullscreen.
3 - Usar outro script de Fullscreen.

Caso queira manter a resolução que o script de Fullscreen define a primeira opção é a mais viável, porém também a mais trabalhosa. Por outro lado, a segunda opção simplesmente torna o script de Fullscreen inútil, te levando a terceira opção.

Pra decidir isso precisaríamos levar em conta qual era sua pretensão ao adicionar o script de Fullscreen no seu projeto. O que você está buscando? Uma resolução maior? Eliminar as bordas pretas do Fullscreen? Bem, eu não sei, mas respondendo essas perguntas você deve ser capaz de se decidir quanto ao que fazer.

Por fim, caso queira mudar o script que está usando, deixo esse aqui como recomendação.

Problema com a resolução

Zombie

26/06/2020 às 23:18

Gabriel

27/06/2020 às 21:36 #1