Σ Fullscreen

[Ven]

Σ Fullscreen

Oe gente, tudo certo? Já tem uns tempinhos que não crio um tópico, mas hoje trouxe um script muito interessante pra maioria de vocês!
Bom, quem usa o ACE já sabe do velho probleminha de resolução de tela, onde não podemos exceder o limite de 640 x 480, que é basicamente o máximo do máximo que a telinha dele aguenta redimensionar.

Porém... vasculhando por terras muito populosas (chamadas Grupos de Facebook). Eu achei um script muito interessante, que permite aumentar a tela do projeto sem puxar os gráficos e deixar aqueles pixels todos distorcidos. O que ela faz é simplesmente aumentar, sem ficar redimensionando os objetos para um tamanho maior.

Ele vai deixar a tela do seu projeto desta forma:

Spoiler

[close]

Claro, existem pontos negativos no uso, mas pro pessoal que tanto reclama do tamanho da janela já é um quebra galho.



Você pode modificar um valor no script que irá decidir quanto a tela deverá ser aumentada, porém, tome cuidado com valores muito altos.
Também é possível ver o limite do seu monitor, pra isso é só você ativar a opção da Janela de Debug.

Para poder modificar o valor, vá até a linha 676. Você está procurando por este código:

Graphics.resize_screen(x, y)

O X e Y que coloquei ali é só pra exemplificar e mostrar melhor, modifique os valores ao seu gosto.

*Caso não saiba a representação de X e Y:
  X é a Largurab] e Y a Altura.

#=============================================================================
# Σ 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

Espero que gostem e façam um bom uso! 

Créditos ao Gabriel "Gab!" Teles.

[Luke•°]

Boa dica, Ven. mas uma dúvida rápida, geralmente os scripts de Fullscreen que existem por ai tem um probleminha em comum, principalmente com o pessoal que usa iluminação por imagens. este problema é justamente o fato das imagens em 640 x 480 não serem redimensionadas juntas aos gráficos do jogo. este script aqui faria isso? ou também teria esse empecilho? confesso que a única desvantagem que vejo nestes Fullscreen's é essa. principalmente para quem usa menu por eventos com imagens, sistema de batalha com HUD ou mapeação por parallax.

[Conjurador]

Esse script é muito bom parabéns ,deixa com uma dinâmica diferente da convencional gostei muito dele ^^

[Ven]

[user]lukewinchester[/user]

Então Luke, esse script apenas aumenta a janela, não redimensiona nada. Testei aqui e as imagens é o usuário que precisa cria-las ou redimensiona-las no valor escolhido. Eu testei a batalha, e você precisara ajustar também os inimigos na tela. Qualquer imagem do projeto devera ser redimensionada no tamanho da janela, mas manualmente.

Agora Windows do próprio maker se esticam sozinhas. Infelizmente é um problema que ele também tem. =/

[Sotelie]

*Bruxaria de scripter desconhecido* aehuaeaehuae E põe bruxaria nisso. Complicado ler o que ele fez ali.
Bem, o script funciona de forma ótima. Modificar o tamanho das imagens utilizadas na tela não é novidade, afinal fazemos isso toda hora quando mudamos para a resolução máxima. Mas o que me preocupava era ele ter incompatibilidade com o Fullscreen++. Até que funcionam juntos, mas dá erro de stack level ao fazer transições pelo fato dos dois modificarem as mesmas coisas. O que é uma pena, mas quando eu voltar a mexer nessas coisas, vou ver o que posso fazer.

[Stella Artois]

Está me dizendo que este script não altera os gráficos e nem o estica mas, aumenta o tamanho do jogo mesmo assim?! O.o
MDS. . .Vou logo testá-lo "huehuehue"
Vlw, mestre Ven!
^^

[Shephiroth]

Script muito bom! Obrigado por dispor :D

[Ven]

[user]Shephiroth[/user]
De nada! Fico muito feliz em ajudar. :D

[user]Sky[/user]
Sim isso mesmo, legal não? Só não uso no meu projeto porque vai dar um trabalhão configurar tudo rs.

[user]Alisson[/user]
Ainda não dei uma estudada no script, tipo, algo mais aprofundado. Mas para que você iria usar os dois juntos, que tipo de combinação queria fazer? Fiquei bem curioso no assunto. :)

[Stella Artois]

De alguma forma, o script não é compatível com 2 scrits que estou usando no momento ;.; isso é bad pois, eu irei ter que resolver este problema daquela maneira. . .
Então, além de afirmar que este script é uma "bruxaria" (- agora que fui entender ashuhauhsas) pois, além de proporcionar mais espaço para as caixas de mensagens e dar um ótimo desempenho visual e agradável para a maioria dos jogadores, queria perguntar duas coisas:
Além da incompartibilidade, queria saber os lados negativos do script citados acima pelo Ven.
E a segunda, eu irei ter que refazer todas as pictures do meu jogo (o que são por volta de 130) para estar compatível com o script, qual seria a resolução da picture? Pois, digamos que a resolução do meu pc é X,Y e a do meu colega, é W,Z. Numa as pictures estariam ajustadas e, na outra, estariam no canto da tela?
Não sei se expliquei muito bem...sorry
2 dias sem dormir xD

[a801901987]

This scripts is free for commercial and non-commercial use?

[makergame2000]

This scripts is free for commercial and non-commercial use?

Yes

[Cristiano Sword]

bom script, nao eh tao dificil assim faze-lo já q o rpgmaker eh td em pixel art

[Username]

De alguma forma, o script não é compatível com 2 scrits que estou usando no momento ;.; isso é bad pois, eu irei ter que resolver este problema daquela maneira. . .
Então, além de afirmar que este script é uma "bruxaria" (- agora que fui entender ashuhauhsas) pois, além de proporcionar mais espaço para as caixas de mensagens e dar um ótimo desempenho visual e agradável para a maioria dos jogadores, queria perguntar duas coisas:
Além da incompartibilidade, queria saber os lados negativos do script citados acima pelo Ven.
E a segunda, eu irei ter que refazer todas as pictures do meu jogo (o que são por volta de 130) para estar compatível com o script, qual seria a resolução da picture? Pois, digamos que a resolução do meu pc é X,Y e a do meu colega, é W,Z. Numa as pictures estariam ajustadas e, na outra, estariam no canto da tela?
Não sei se expliquei muito bem...sorry
2 dias sem dormir xD

Se você criar o jogo na resolução 800 x 600 , terá suas imagens configuradas visualmente "certas" para esta resolução.

Mas se você quiser criar um jogo com resolução 1920 x 1080 , terá que refazer suas imagens visualmente "certas" aos olhos para esta resolução, independente da resolução do usuário final.

Você estará dispondo de 2 opções de resolução, porém o trabalho de faze-las funcionar é seu, e terá que fazer duas vezes.

Uma coisa interessante, é que, quanto mais pixels uma tela pode mostrar, mais informação (detalhes de uma imagem)  uma tela que aceite resolução maior pode mostrar. Veja a imagem do trem vermelho neste link e sua explicação:  https://www.infowester.com/resolucoes.php

___

Quanto a isto também fiquei curioso:

"Até que funcionam juntos, mas dá erro de stack level ao fazer transições pelo fato dos dois modificarem as mesmas coisas. O que é uma pena, mas quando eu voltar a mexer nessas coisas, vou ver o que posso fazer."

O que são essas transições? O fade in e fade out do jogo? Ele buga quando  acontece o que? Duas coisas iguais buga? (A resolução da tela e do jogo iguais?)

E isso poderia virar falha no RPG Maker e ser explorado, por curiosidade?


Obrigado.