Aula Ativa de Javascript/Ruby/RGSS e outras linguagens de programação

[Alucard_2]

@Watanukiz
Fica difícil saber o que está errado se não sabemos nem como usou =T Poderia postar seu código?
E aliás, o que seria IR?

[MendigoDoMato]

Isso aqui ta funcionando ? posso fazer perguntas por aqui ainda ?

[Raizen]

Sim, desculpe a demora, se ainda tiver perguntas sobre isso só mandar, também generalizei mais o tópico para quem quiser perguntar de outras linguagens de programação

[Baby..Face]

Engine: RMVX Ace
Explicação: Gostaria de saber se existe a possibilidade de redimensionar janelas (Window_Selectable, Window_Base, etc ), a um tamanho perfeito ao conteúdo que ela vai conter de forma "automática", ou seja, quando instanciar a janela atribuir valores arbitrários e após adicionar o conteúdo à janela, alterá-la de forma a se ajustar ao conteúdo inserido.
Por exemplo primeiro é necessário instanciar.

Até o momento minha solução "gambiarrosa" funciona para quantidade de linhas que a janela conterá.
Eu crio uma janela dummy, uma janela qualquer só para que eu possar acessar o método fitting_height, em seguida utilizo o
esse método passando o valor 2, para que ele calcule a altura ideal da janela para duas linhas (minha Window_Selectable, conterá duas opções). Não consigo fazer nada semelhante para a largura da janela.

Então.. Gostaria de saber se tem uma solução mais elegante, e que funcione também pra largura da janela.
Só mais um acréscimo, já vi que existem diversos scripts de caixa de mensagem, principalmente os que alteram a caixa de texto padrão para uma no estilo "balãozinho" que isso é bem evidente, o tamanho dela se ajusta ao conteúdo que contém, basicamente essa é minha dúvida, se tem como fazer isso de forma simples individual para as janelas de meu interesse.

Código exemplo1: Scene para teste
#Criei uma scene para teste, em que:

class Planting_Scene < Scene_Base
  def start
    super
    #`Para adicionar um fundo à scene:
    @background = Sprite.new #Cria-se um novo sprite
    @background.bitmap = SceneManager.background_bitmap #Extrai o fundo da Scene
    
    dummy_window = Window_Base.new(0,0,0,0)
    vertical_content_height = dummy_window.fitting_height(2)
    @planting_selectable = Planting_Selectable.new( 0 , 0, 
        320, vertical_content_height )
    
  end
end

Window Selectable:

class Planting_Selectable < Window_Selectable
  def initialize( x, y , width , height )
    self.create_commands_list()
    super
    self.fitting_height( 2 )
    self.update()
    self.draw_commands()
    #Ativa a janela para que seja utilizada
    self.activate()
    #Faz o cursor aparecer na primeira opção da janela
    self.select( 0 )
  end
  
  #O método update das janelas é chamado em todas as scenes 
  def update
    super
    #Se o botão de decisão for pressionado e a janela estiver ativa
    if Input.trigger?(:C) && self.active
      Sound.play_ok
      chosen_option = @list[ self.index() ]
      run_option( chosen_option)
    end
  end
  
  def create_commands_list()
    @list = []
    commands = ["Plantar", "Sair"]
      for i in 0...commands.size
        @list.push( commands[i] )
      end
  end
  
  def draw_commands()
    for i in 0...@list.size
      #Cria um retângulo com o tamanho e posição correto para desenhar o texto
      #   do comando
      rect = self.item_rect(i)
      #Desenha no rect o comando de @list[i]
      self.draw_text( rect , @list[i] )
    end
  end #draw_commands()
  
  def item_max
    #Se a lista não foi instanciada, retorna 0
    if @list.nil?
      return 0
    else
    #Senão, retorna o tamanho da lista
      return @list.size
    end
  end #item_max
  
  def run_option( chosen_option )
    case chosen_option
    when "Plantar"
      msgbox("Opção escolhida foi Plantar")
    when "Sair"
      SceneManager.return
    end
  end
  
end #class

Segue em anexo imagem com o resultado.

Pois bem essas são minhas dúvidas. Esses código foram baseado nas aulas de Ruby do Alisson de Window_Selectable, portanto muito obrigado Alisson! Já aprendi algumas coisas 

[Anexo excluído pelo administrador]

[Sotelie]

Fico feliz que as aulas deram frutos.
Fiz um pequeno teste aqui que talvez possa te dar uma luz:

class Test_Window < Window_Base
  
  def initialize(x = 0, y = 0)
    # Estarei realizando o super padrão com 1/1 de dimensões para a janela.
    # Isso é apenas para garantir que não haverão erros, embora você possa sim
    # criar uma janela com 0/0 de dimensões.
    super(x, y, 1, 1)
    draw_stuff
  end
  
  # Estarei usando esse método para desenhar as coisas.
  # Note que o que fiz aqui serve apenas como demonstração, você pode querer
  # caprichar mais para deixar o código mais limpo criando a lista de
  # itens a serem desenhados externamente.
  def draw_stuff
    # Aqui estarei criando uma hash que será responsável por obter as dimensões
    # finais dos itens a serem desenhados.
    # Estas dimensões irão se expandir até caberem os itens a serem desenhados.
    dimensions = {:width => 0, :height => 0}
    
    # Nesta parte estarei chamando o método de exemplo "process_text_dimensions"
    # para que ele calcule as dimensões necessárias do texto a ser desenhado.
    # Recomendo que veja os exemplos abaixo e tente fazer com ícones, faces
    # e outras coisas.
    # Vale notar que ele modifica a variável local "dimensions" se for necessário.
    process_text_dimensions("Hey There!", 0, 0, dimensions)
    process_text_dimensions("Just some text.", 100, line_height, dimensions)
    process_text_dimensions("Another text in here.", 20, line_height * 2, dimensions)
    
    # Após ter calculado as dimensões necessárias, é hora de criar um bitmap
    # com as mesmas dimensões calculadas. Esse bitmap será usado como
    # o conteúdo final da janela.
    # Vou chamar o método "recreate_contents" que criei apenas para isso.
    recreate_contents(Bitmap.new(dimensions[:width], dimensions[:height]))
    
    # Após ter criado o bitmap de conteúdo da janela, podemos enfim desenhar
    # as coisas nela.
    # Eu recomendo usar as mesmas coordenadas/dimensões que usamos para
    # calcular o espaço necessário durante a criação das dimensões.
    draw_text_ex(0, 0, "Hey There!")
    draw_text_ex(100, line_height, "Just some text.")
    draw_text_ex(20, line_height * 2, "Another text in here.")
  end
  
  # Este método será encarregado de calcular as dimensões necessárias para
  # se desenhar um texto na janela.
  # Ele modifica a hash "dimensions" que usamos caso for necessário.
  def process_text_dimensions(text, x, y, out_dimensions)
    # Aqui obtemos o retângulo que determina as dimensões verdadeiras do
    # texto na janela.
    rect = contents.text_size(text)
    
    # Nesta parte nós calculamos as dimensões totais para se desenhar o texto nela.
    # Note que eu adicionei 2 na largura pois o Ace possui um erro ao calcular
    # a largura do texto em alguns casos. Isso não acontecia no XP nem no VX.
    calculated_width = x + rect.width + 2
    calculated_height = y + rect.height
    
    # Agora nós iremos checar se as dimensões atuais que passamos são menores
    # que as dimensões necessárias.
    # Caso elas sejam, ele irá alterar as dimensões que passamos.
    # Do contrário, ele não faz nenhuma alteração.
    # Precisamos fazer isso para a largura E altura, então nada de elsif.
    if out_dimensions[:width] < calculated_width
      out_dimensions[:width] = calculated_width
    end
    if out_dimensions[:height] < calculated_height
      out_dimensions[:height] = calculated_height
    end
  end
  
  # E por fim, este é o método que irá recriar o bitmap do conteúdo da janela.
  def recreate_contents(source_bitmap)
    # Como nós criamos o bitmap assim que o passamos como argumento,
    # não precisamos dar dispose nele.
    self.contents = source_bitmap
    
    # A largura da janela é a largura do conteúdo dela, somado com o padding
    # multiplicado por 2 (visto que temos padding na esquerda e na direita).
    self.width = contents.width + padding * 2
    
    # A mesma coisa do padding da largura se aplica ao padding da altura.
    self.height = contents.height + padding * 2
    
    # Se você não souber, o padding indica o quão longe da borda da janela
    # o conteúdo fica. Por padrão, é 12.
  end
  
end

Creio que se tiver entendido o conceito, você pode melhorar esse código, haha'

[Baby..Face]

Valeuzão por responder Alisson, no momento não posso olhar com calma a sua solução mas assim que puder estudarei seu código e comento.
Mais uma vez, valeus!

[Raizen]

Só avisando que atualizei o tópico para incluir Javascript, antes estava voltado ao Ruby apenas, então caso tenham dúvidas rápidas de JS podem usar esse tópico também para resolverem. 

[MayLeone]

Eu sei que não é uma linguagem muita utilizada nesse fórum, mas se tiverem dúvidas sobre C# podem postar aqui também que ficarei feliz em poder ajudar. 

[Crewyvern]

Não sei se o tópico ainda é ativo ou se é aqui o lugar certo pra perguntar, mas estou com uma dúvida, comecei a estudar rgss3 ontem, e testando algumas coisas cheguei numa parte que não entendi o porque disso acontecer...

Spoiler

class Teste2
  def initialize
    @var3 = 399
    $var2 = 394
    @var4 = 773
    @var5 = 464
    @var = palavra
  end
  def er
    if @var3 == 399
      p @var3
    end
  end
  def era
    if not $var2 == 393
      p @var4
    end
  end
  def ueo
    if @var3 == 390 or @var5 == 464
      p @var2
    end 
  end
  def qdj
    p @var
  end 
  
end
classe = Teste2.new
classe.er
classe.era
classe.ueo
classe.qdj

[close]

Até aqui  "if @var3 == 390 or @var5 == 464" funcionava, porém como eu coloquei um "or" coloquei @var3 errado e o @var5 correto, na minha cabeça se um deles estivesse correto printaria na janela de depuração o "p @var2", porém deu nil, porque isso?
E a outra dúvida é, eu coloquei @var = palavra, mas depois disso deu erro e agora vem a pergunta, não pode colocar letras em variáveis?

[Gabriel]

O problema com o retorno nil de @var2 acontece porque você não definiu @var2. Veja com atenção o seu código e encontrará o erro. Você definiu $var2, que é uma variável global, diferente da variável de instância @var2.

Para guardar textos em uma variável como string você precisa utilizar aspas.

Código: Exemplo:

@var = "palavra"

[Crewyvern]

O problema com o retorno nil de @var2 acontece porque você não definiu @var2. Veja com atenção o seu código e encontrará o erro. Você definiu $var2, que é uma variável global, diferente da variável de instância @var2.

Para guardar textos em uma variável como string você precisa utilizar aspas.

Código: Exemplo:

@var = "palavra"

Obrigado moço, nossa não tinha visto, agora funcionou certinho, preciso prestar mais atenção.
Provavelmente vou perguntar mais coisas logo, bem difícil aprender algo sem poder tirar dúvidas

[Crewyvern]

Eu cheguei na parte de attr, estou vendo as aulas do Khas, porém eu não entendi muito bem pra que serve attr, eu fiz uns testes pra entender melhor como funciona, primeiro eu fiz classes e defini um "initialize" na primeira, e coloquei as variáveis no attr, até onde entendi eu posso acessar o initialize da primeira classe desde tenham as heranças e attr.

Também sei que só posso acessar attr (accesor/reader) o writer deu erro na hora de mandar printar, porque disse que não tem um método definido.

Depois eu retirei o attr e testei, então deu um erro aqui ( class Teste02 < Teste01/   def g/ if lox == "or" ), entendi que mesmo com heranças eu não posso acessar o initialize da primeira classe sem attr.

Porém na classe Teste03 eu chamei um attr (obj = Teste03.new/ n = obj.ked/ p obj.ked), mas pra que? não entendi pra que serviu, só pra chamar?

Pelo menos na minha cabeça eu entendi algumas coisas, se caso falei besteira e não entendi nada me ajudem plis.
Espero que dê pra entender

Spoiler

class Teste01 #com attr
   attr_reader :eke
   attr_reader :ekp
   attr_reader :ked
   attr_accessor :kad
   attr_accessor :lox
  def initialize
    @eke = 38345
    @ekp = 372
    @ked = 182.32
    @kad = "temd"
    @lox = "or"
  end
  def y
    if @eke == 38345
      p " aaa"
    end
  end
end

var = Teste01.new
var.y

class Teste02 < Teste01 #com herança
  def g
    if lox == "or"
      p @eke
      p @kad
    end
  end
  def m
    if lox == "or"
      p lox
    end
  end
  def y
    if ekp == 372
      p "nao"
      super
    end
  end
end

var = Teste02.new
var.g
var.m
var.y

class Teste03 < Teste02 #com herança/attr
  def x
    if @ked == 182.32
      p "000"
    end
  end
end

obj = Teste03.new
n = obj.ked
p obj.ked

var = Teste03.new
var.x

[close]

[Gabriel]

Não entendi bem qual é a sua dúvida, mas, de toda forma, recomendo que estude as aulas de Ruby feitas pelo Alisson. Provavelmente você não vai encontrar em nenhum outro lugar um material mais completo que esse a respeito do assunto, quando voltado para o RPG Maker.

Aulas de Ruby #13 - Attr
Aulas de Ruby

[Raizen]

Com certeza na aula acima do tio Ali deve explicar muito bem o que é, mas vou aproveitar o tempinho que tenho aqui para mandar um adicional também  .

No Ruby as variáveis tem visibilidades igual boa parte se não todas as linguagens orientadas a objetos. Os atributos no ruby que são definidos pelo attr nada mais são do que adicionar um tipo de visibilidade para as variáveis de instância. As variáveis de instância no Ruby são semelhantes as variáveis privadas de outras linguagens, elas são visíveis apenas dentro da classe aonde foi declarada, existe um tipo de variável nas linguagens que são as variáveis públicas. Elas não tem declaração especifica no Ruby, essas variáveis públicas são as que podem ser acessadas fora da classe, no Ruby o que é feito é transformar aquela variável de instância (precedidas por @) em atributo.

as diferenças de writer, accessor e reader são as permissões que vou dar em relação aos acessos externos a classe, então se eu dou um acesso de reader a variável de instância, ela pode ser lida fora da classe, porém ela não pode ser modificada. Se for writer então ela pode ser modificada, mas não pode ser lida e se for accessor, você tem acesso completo a variável fora da própria classe.

Porque é esse nome attr? Bom como dito é porque veio de "attribute", ele significa que eu pego a variável de instância e transformo em um atributo da classe, ou sejá, quando você faz essa declaração:

class Test
attr_accessor :teste

  def init
    @teste = 2
  end
end

Então inicializo a minha classe.

test = Test.new

test.teste retorna 2,
e também posso modificar, já que dei a permissão para tal.

test.teste += 2

test.teste vai retornar 4

Mais alguma dúvida :)? Ah veja o video do Alisson antes, se ainda houver dúvidas só mandar aqui!

[Sotelie]

Adicionando ao que os amigos acima disseram, isso é o que a virtual machine do ruby faz por trás dos panos quando você usa attr_*, caso estiver curioso:

Em ruby isso é chamado de atributo, mas em programação geral, o termo correto para isso é Propriedade (ou Property em inglês). Apenas tenha em mente que elas são uma forma de você escolher que variáveis podem ser públicas e quais devem ser privadas. Muitas das vezes quando criamos classes, temos aquela variável que não deve ser alterada de fora de maneira alguma, do contrário pode gerar erros no programa. Você que decide se quer deixar algo público ou não, se julgar necessário o/