Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 4068 miembros registrados.
El último usuario registrado es Schwarz54.

Nuestros miembros han publicado un total de 84121 mensajes en 11982 argumentos.

[Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Ver el tema anterior Ver el tema siguiente Ir abajo

[Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Mensaje por Wecoc el 2013-12-07, 17:44

[Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Partiremos del siguiente script de ejemplo, que es el que queremos reducir el número de líneas sin perder información.

Spoiler:

Código:
class Game_System
  attr_accessor :a_plus
  attr_accessor :b_plus
  attr_accessor :c_plus
  attr_accessor :d_plus
  attr_accessor :e_plus
  attr_accessor :f_plus

  def initialize
    @map_interpreter = Interpreter.new(0, true)
    @battle_interpreter = Interpreter.new(0, false)
    @timer = 0
    @timer_working = false
    @save_disabled = false
    @menu_disabled = false
    @encounter_disabled = false
    @message_position = 2
    @message_frame = 0
    @save_count = 0
    @magic_number = 0
    @a_plus = 0
    @b_plus = 0
    @c_plus = 0
    @d_plus = 0
    @e_plus = 0
    @f_plus = 0
  end
end

class Window_Test < Window_Base
  attr_accessor :a_value
  attr_accessor :b_value
  attr_accessor :c_value
  attr_accessor :d_value
  attr_accessor :e_value
  attr_accessor :f_value
  
  def initialize
    super(0, 0, 400, 400)
    self.contents = Bitmap.new (self.width - 32, self.height - 32)
    @a_value = 0
    @b_value = 2
    @c_value = 1
    @d_value = 0
    @e_value = 0
    @f_value = 1
  end
  
  def calculate_a
    p "a"
    value = @a_value
    value += $game_system.a_plus
    draw_a(value)
    @a_value = 0
    return value
  end
  
  def calculate_b
    p "b"
    value = @b_value
    value += $game_system.b_plus
    draw_b(value)
    @b_value = 0
    return value
  end
  
  def calculate_c
    p "c"
    value = @c_value
    value += $game_system.c_plus
    draw_c(value)
    @c_value = 0
    return value
  end
  
  def calculate_d
    p "d"
    value = @d_value
    value += $game_system.d_plus
    draw_d(value)
    @d_value = 0
    return value
  end
  
  def calculate_e
    p "e"
    value = @e_value
    value += $game_system.e_plus
    draw_e(value)
    @e_value = 0
    return value
  end

  def calculate_f
    p "f"
    value = @f_value
    value += $game_system.f_plus
    draw_f(value)
    @f_value = 0
    return value
  end

  def draw_a(value)
    if value != nil
      self.contents.draw_text(0, 0, 100, 32, "This is a test. A!")
    end
  end
  
  def draw_b(value)
    if value != nil
      self.contents.draw_text(0, 0, 100, 32, "This was a test. B!")
    end
  end
  
  def draw_c(value)
    if value == 0
      var = true
    else
      var = false
    end
    if var == true
      self.contents.draw_text(20, 0, 100, 32, "This is true. C!")
    else
      self.contents.draw_text(20, 0, 100, 32, "This is false. C!")
    end
  end

  def draw_d(value)
    if value == 0
      self.contents.draw_text(0, 10, 64, 32, "Hola. D!")
    else
      self.contents.draw_text(0, 10, 64, 32, "Adios. D!")
    end
  end
  
  def draw_e(value)
    var_case = @a_value + @b_value + @c_value - @d_value
    case var_case
    when 0
      self.contents.draw_text(0, 0, 640, 32, "Fire, E!")
    when 1
      self.contents.draw_text(20, 0, 640, 32, "Ice, E!")
    when 2
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 3
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 4
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 5
      self.contents.draw_text(20, 0, 640, 32, "Earth, E!")
    else
      self.contents.draw_text(0, 0, 640, 32, "Darkness or some scary shit, E!")
    end
  end
  
  def draw_f(value)
    self.contents.draw_text(12, 12, 100, 32, "F. Just F.")
  end
end
159 líneas

Para reducirlas seguiremos los siguientes pasos. Los "#" son referencias en el script.

1) Poner alias donde se pueda

El alias es un método que se usa para llamar a algo ya escrito previamente y poder modificarlo desde allí sin tener que volver a escribirlo todo.
El ejemplo usa Game_System y su def initialize puede reducirse con el alias.

Spoiler:

Código:
class Game_System
  attr_accessor :a_plus
  attr_accessor :b_plus
  attr_accessor :c_plus
  attr_accessor :d_plus
  attr_accessor :e_plus
  attr_accessor :f_plus

  alias testing_initialize initialize unless $@ #
  def initialize
    testing_initialize #
    @a_plus = 0
    @b_plus = 0
    @c_plus = 0
    @d_plus = 0
    @e_plus = 0
    @f_plus = 0
  end
end

class Window_Test < Window_Base
  attr_accessor :a_value
  attr_accessor :b_value
  attr_accessor :c_value
  attr_accessor :d_value
  attr_accessor :e_value
  attr_accessor :f_value
  
  def initialize
    super(0, 0, 400, 400)
    self.contents = Bitmap.new (self.width - 32, self.height - 32)
    @a_value = 0
    @b_value = 2
    @c_value = 1
    @d_value = 0
    @e_value = 0
    @f_value = 1
  end
  
  def calculate_a
    p "a"
    value = @a_value
    value += $game_system.a_plus
    draw_a(value)
    @a_value = 0
    return value
  end
  
  def calculate_b
    p "b"
    value = @b_value
    value += $game_system.b_plus
    draw_b(value)
    @b_value = 0
    return value
  end
  
  def calculate_c
    p "c"
    value = @c_value
    value += $game_system.c_plus
    draw_c(value)
    @c_value = 0
    return value
  end
  
  def calculate_d
    p "d"
    value = @d_value
    value += $game_system.d_plus
    draw_d(value)
    @d_value = 0
    return value
  end
  
  def calculate_e
    p "e"
    value = @e_value
    value += $game_system.e_plus
    draw_e(value)
    @e_value = 0
    return value
  end

  def calculate_f
    p "f"
    value = @f_value
    value += $game_system.f_plus
    draw_f(value)
    @f_value = 0
    return value
  end

  def draw_a(value)
    if value != nil
      self.contents.draw_text(0, 0, 100, 32, "This is a test. A!")
    end
  end
  
  def draw_b(value)
    if value != nil
      self.contents.draw_text(0, 0, 100, 32, "This was a test. B!")
    end
  end
  
  def draw_c(value)
    if value == 0
      var = true
    else
      var = false
    end
    if var == true
      self.contents.draw_text(20, 0, 100, 32, "This is true. C!")
    else
      self.contents.draw_text(20, 0, 100, 32, "This is false. C!")
    end
  end

  def draw_d(value)
    if value == 0
      self.contents.draw_text(0, 10, 64, 32, "Hola. D!")
    else
      self.contents.draw_text(0, 10, 64, 32, "Adios. D!")
    end
  end
  
  def draw_e(value)
    var_case = @a_value + @b_value + @c_value - @d_value
    case var_case
    when 0
      self.contents.draw_text(0, 0, 640, 32, "Fire, E!")
    when 1
      self.contents.draw_text(20, 0, 640, 32, "Ice, E!")
    when 2
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 3
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 4
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 5
      self.contents.draw_text(20, 0, 640, 32, "Earth, E!")
    else
      self.contents.draw_text(0, 0, 640, 32, "Darkness or some scary shit, E!")
    end
  end
  
  def draw_f(value)
    self.contents.draw_text(12, 12, 100, 32, "F. Just F.")
  end
end
150 líneas

# El alias de métodos (def) típico se usa de la siguiente manera:
Código:
alias nuevo_nombre nombre unless $@
def nombre(argumentos)
  nuevo_nombre(argumentos)
  # cosas nuevas
end
2) Resumir condicionales

Los condicionales son los if y unless básicamente y tienen diferentes métodos para resumirse

Spoiler:

Código:
class Game_System
  attr_accessor :a_plus
  attr_accessor :b_plus
  attr_accessor :c_plus
  attr_accessor :d_plus
  attr_accessor :e_plus
  attr_accessor :f_plus

  alias testing_initialize initialize unless $@
  def initialize
    testing_initialize
    @a_plus = 0
    @b_plus = 0
    @c_plus = 0
    @d_plus = 0
    @e_plus = 0
    @f_plus = 0
  end
end

class Window_Test < Window_Base
  attr_accessor :a_value
  attr_accessor :b_value
  attr_accessor :c_value
  attr_accessor :d_value
  attr_accessor :e_value
  attr_accessor :f_value
  
  def initialize
    super(0, 0, 400, 400)
    self.contents = Bitmap.new (self.width - 32, self.height - 32)
    @a_value = 0
    @b_value = 2
    @c_value = 1
    @d_value = 0
    @e_value = 0
    @f_value = 1
  end
  
  def calculate_a
    p "a"
    value = @a_value
    value += $game_system.a_plus
    draw_a(value)
    @a_value = 0
    return value
  end
  
  def calculate_b
    p "b"
    value = @b_value
    value += $game_system.b_plus
    draw_b(value)
    @b_value = 0
    return value
  end
  
  def calculate_c
    p "c"
    value = @c_value
    value += $game_system.c_plus
    draw_c(value)
    @c_value = 0
    return value
  end
  
  def calculate_d
    p "d"
    value = @d_value
    value += $game_system.d_plus
    draw_d(value)
    @d_value = 0
    return value
  end
  
  def calculate_e
    p "e"
    value = @e_value
    value += $game_system.e_plus
    draw_e(value)
    @e_value = 0
    return value
  end

  def calculate_f
    p "f"
    value = @f_value
    value += $game_system.f_plus
    draw_f(value)
    @f_value = 0
    return value
  end

  def draw_a(value)
    self.contents.draw_text(0, 0, 100, 32, "This is a test. A!") if value != nil #
  end
  
  def draw_b(value)
    self.contents.draw_text(0, 0, 100, 32, "This was a test. B!") if value != nil #
  end
  
  def draw_c(value)
    var = (value == 0) ##
    self.contents.draw_text(20, 0, 100, 32, "This is #{var}. C!") ##
  end

  def draw_d(value)
    self.contents.draw_text(0, 10, 64, 32, value == 0 ? "Hola. D!" : "Adios. D!") ###
  end
  
  def draw_e(value)
    var_case = @a_value + @b_value + @c_value - @d_value
    case var_case
    when 0
      self.contents.draw_text(0, 0, 640, 32, "Fire, E!")
    when 1
      self.contents.draw_text(20, 0, 640, 32, "Ice, E!")
    when 2
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 3
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 4
      self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 5
      self.contents.draw_text(20, 0, 640, 32, "Earth, E!")
    else
      self.contents.draw_text(0, 0, 640, 32, "Darkness or some scary shit, E!")
    end
  end
  
  def draw_f(value)
    self.contents.draw_text(12, 12, 100, 32, "F. Just F.")
  end
end
134 líneas

# Condicionales que solo tienen una línea en el interior se pueden poner a una sola línea quitando el def y poniendo el if al final de la línea
Código:
if a == b
  n = 0
end
es lo mismo que poner
Código:
n = 0 if a == b
## Los condicionales valen true cuando se cumplen y false cuando no, así que es lo mismo poner
Código:
if a == b
  return true
else
  return false
end
que poner
Código:
return a == b
### Existe otro método para poner los if a una sola línea incluso si tienen then, usando ? La ventaja de ésto es que no tiene que estar a principio de línea
En general se escribe:
condición ? se cumple : no se cumple

Código:
if a == b
  x = true
else
  y = true
end
es lo mismo que poner
Código:
a == b ? x = true : y = true
Código:
if a == b
  x = 0
else
  x = 1
end
es lo mismo que poner
Código:
x = (a == b ? 0 : 1)
3) Resumir case y quitar variables innecesarias

Spoiler:

Código:
class Game_System
  attr_accessor :a_plus
  attr_accessor :b_plus
  attr_accessor :c_plus
  attr_accessor :d_plus
  attr_accessor :e_plus
  attr_accessor :f_plus

  alias testing_initialize initialize unless $@
  def initialize
    testing_initialize
    @a_plus = 0
    @b_plus = 0
    @c_plus = 0
    @d_plus = 0
    @e_plus = 0
    @f_plus = 0
  end
end

class Window_Test < Window_Base
  attr_accessor :a_value
  attr_accessor :b_value
  attr_accessor :c_value
  attr_accessor :d_value
  attr_accessor :e_value
  attr_accessor :f_value
  
  def initialize
    super(0, 0, 400, 400)
    self.contents = Bitmap.new (self.width - 32, self.height - 32)
    @a_value = 0
    @b_value = 2
    @c_value = 1
    @d_value = 0
    @e_value = 0
    @f_value = 1
  end
  
  def calculate_a
    p "a"
    value = @a_value
    value += $game_system.a_plus
    draw_a(value)
    @a_value = 0
    return value
  end
  
  def calculate_b
    p "b"
    value = @b_value
    value += $game_system.b_plus
    draw_b(value)
    @b_value = 0
    return value
  end
  
  def calculate_c
    p "c"
    value = @c_value
    value += $game_system.c_plus
    draw_c(value)
    @c_value = 0
    return value
  end
  
  def calculate_d
    p "d"
    value = @d_value
    value += $game_system.d_plus
    draw_d(value)
    @d_value = 0
    return value
  end
  
  def calculate_e
    p "e"
    value = @e_value
    value += $game_system.e_plus
    draw_e(value)
    @e_value = 0
    return value
  end

  def calculate_f
    p "f"
    value = @f_value
    value += $game_system.f_plus
    draw_f(value)
    @f_value = 0
    return value
  end

  def draw_a(value)
    self.contents.draw_text(0, 0, 100, 32, "This is a test. A!") if value != nil
  end
  
  def draw_b(value)
    self.contents.draw_text(0, 0, 100, 32, "This was a test. B!") if value != nil
  end
  
  def draw_c(value)
    self.contents.draw_text(20, 0, 100, 32, "This is #{(value == 0)}. C!") #
  end

  def draw_d(value)
    self.contents.draw_text(0, 10, 64, 32, value == 0 ? "Hola. D!" : "Adios. D!")
  end
  
  def draw_e(value)
    case (@a_value + @b_value + @c_value - @d_value) # ##
    when 0 then self.contents.draw_text(0, 0, 640, 32, "Fire, E!")
    when 1 then self.contents.draw_text(20, 0, 640, 32, "Ice, E!")
    when 2, 3, 4 then self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 5 then self.contents.draw_text(20, 0, 640, 32, "Earth, E!")
    else
      self.contents.draw_text(0, 0, 640, 32, "Darkness or some scary shit, E!")
    end
  end
  
  def draw_f(value)
    self.contents.draw_text(12, 12, 100, 32, "F. Just F.")
  end
end
124 líneas

# Usar variables innecesarias (por ejemplo hacer a = b + 1 y hacer cosas usando a, pudiendo usar simplemente b + 1) puede incrementar el número de líneas.
Las variables que solo se usan una vez son el claro ejemplo.

Código:
x = a + b + c
case x
(...)
end
es lo mismo que poner
Código:
case (a + b + c)
(...)
end
## Case con condiciones repetidas se pueden resumir poniendo en un mismo when más de un valor o incluso un rango.
Además, si dentro de ese when solo hay una línea, se puede resumir a la misma usando then

Código:
case a
when 0
  return b
when 1
  return b
when 2
  return -b
when 3
  return -b
end
es lo mismo que poner
Código:
case a
  when 0, 1 then return b
  when 2, 3 then return -b
end
4) Usar attr_accessor, attr_reader y attr_writer

attr_accessor, attr_reader y attr_writer son en sí métodos para tener lo mismo con menos métodos

Por ejemplo
Código:
def a
  return @a
end

def a=(value)
  @a = value
end
es lo mismo que poner
Código:
attr_accessor :a
Con los demás;

Código:
def a
  return @a
end
es lo mismo que
Código:
attr_reader :a
Código:
def a=(value)
  @a = value
end
es lo mismo que
Código:
attr_writer :a

Además en uno mismo se pueden poner más de uno separados por comas (o eso he oído xD) Sería más o menos como cuando pones por comas las igualdades (##)
Código:
attr_accessor :a, :b, :c, :d
Código:
a = 0
b = 1
c = 3
d = 2
e = 4
es lo mismo que poner
Código:
a, b, c, d, e = 0, 1, 3, 2, 4
Spoiler:

Código:
class Game_System
  ARRAY = ["a", "b", "c", "d", "e", "f"] #
  for i in 0..ARRAY.size #
    attr_accessor "#{ARRAY[i]}_plus" #
  end #

  alias testing_initialize initialize unless $@
  def initialize
    testing_initialize
    @a_plus, @b_plus, @c_plus = 0, 0, 0 ##
    @d_plus, @e_plus, @f_plus = 0, 0, 0 ##
  end
end

class Window_Test < Window_Base
  ARRAY = ["a", "b", "c", "d", "e", "f"] #
  for i in 0..ARRAY.size #
    attr_accessor "#{ARRAY[i]}_value" #
  end #
  
  def initialize
    super(0, 0, 400, 400)
    self.contents = Bitmap.new (self.width - 32, self.height - 32)
    @a_value, @b_value, @c_value = 0, 2, 1 ##
    @d_value, @e_value, @f_value = 0, 0, 1 ##
  end
  
  def calculate_a
    p "a"
    value = @a_value
    value += $game_system.a_plus
    draw_a(value)
    @a_value = 0
    return value
  end
  
  def calculate_b
    p "b"
    value = @b_value
    value += $game_system.b_plus
    draw_b(value)
    @b_value = 0
    return value
  end
  
  def calculate_c
    p "c"
    value = @c_value
    value += $game_system.c_plus
    draw_c(value)
    @c_value = 0
    return value
  end
  
  def calculate_d
    p "d"
    value = @d_value
    value += $game_system.d_plus
    draw_d(value)
    @d_value = 0
    return value
  end
  
  def calculate_e
    p "e"
    value = @e_value
    value += $game_system.e_plus
    draw_e(value)
    @e_value = 0
    return value
  end

  def calculate_f
    p "f"
    value = @f_value
    value += $game_system.f_plus
    draw_f(value)
    @f_value = 0
    return value
  end

  def draw_a(value)
    self.contents.draw_text(0, 0, 100, 32, "This is a test. A!") if value != nil
  end
  
  def draw_b(value)
    self.contents.draw_text(0, 0, 100, 32, "This was a test. B!") if value != nil
  end
  
  def draw_c(value)
    self.contents.draw_text(20, 0, 100, 32, "This is #{(value == 0)}. C!")
  end

  def draw_d(value)
    self.contents.draw_text(0, 10, 64, 32, value == 0 ? "Hola. D!" : "Adios. D!")
  end
    
  def draw_e(value)
    case (@a_value + @b_value + @c_value - @d_value)
    when 0 then self.contents.draw_text(0, 0, 640, 32, "Fire, E!")
    when 1 then self.contents.draw_text(20, 0, 640, 32, "Ice, E!")
    when 2, 3, 4 then self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 5 then self.contents.draw_text(20, 0, 640, 32, "Earth, E!")
    else
      self.contents.draw_text(0, 0, 640, 32, "Darkness or some scary shit, E!")
    end
  end
  
  def draw_f(value)
    self.contents.draw_text(12, 12, 100, 32, "F. Just F.")
  end
end
112 líneas

# Lo que mucha gente no sabe es que los attr_accessor, attr_reader y attr_writer pueden llamarse por string y no symbol, eso permite llamar muchos repetitivos al mismo tiempo con un for.

Código:
attr_accessor :armor1
attr_accessor :armor2
attr_accessor :armor3
attr_accessor :armor4
attr_accessor :armor5
attr_accessor :armor6
attr_accessor :armor7
attr_accessor :armor8
attr_accessor :armor9
attr_accessor :armor10
es lo mismo que poner
Código:
for i in 1..10
  attr_accessor "armor#{i}"
end
5) Compactar métodos similares en uno solo

Algunos métodos son exactamente lo mismo pero para parámetros diferentes, por ejemplo el cálculo de base_str, el de base_dex, el de base_agi y el de base_int en los scripts por defecto.
Todo ésto se puede resumir en uno solo usando un argumento, en el case anterior sería base(value) donde value puede ser "str", "dex", "agi" o "int" (#). Para ello tendremos que considerar la posibilidad de que
ninguno de los valores de value sea correcto y eso implicará añadir una línea demás (##), pero vale la pena.

Spoiler:

Código:
class Game_System
  ARRAY = ["a", "b", "c", "d", "e", "f"]
  for i in 0..ARRAY.size
    attr_accessor "#{ARRAY[i]}_plus"
  end

  alias testing_initialize initialize unless $@
  def initialize
    testing_initialize
    @a_plus, @b_plus, @c_plus = 0, 0, 0
    @d_plus, @e_plus, @f_plus = 0, 0, 0
  end
end

class Window_Test < Window_Base
  ARRAY = ["a", "b", "c", "d", "e", "f"]
  for i in 0..ARRAY.size
    attr_accessor "#{ARRAY[i]}_value"
  end
  
  def initialize
    super(0, 0, 400, 400)
    self.contents = Bitmap.new (self.width - 32, self.height - 32)
    @a_value, @b_value, @c_value = 0, 2, 1
    @d_value, @e_value, @f_value = 0, 0, 1
  end
  
  def calculate(val) #
    return unless ARRAY.include?(val) ##
    p val ###
    value = method("#{val}_value").call ###
    value += $game_system.send("#{val}_plus".to_sym) ####
    method("draw_#{val}").call(value) ###
    method("#{val}_value=").call(0) ###
    return value
  end

  def draw_a(value)
    self.contents.draw_text(0, 0, 100, 32, "This is a test. A!") if value != nil
  end
  
  def draw_b(value)
    self.contents.draw_text(0, 0, 100, 32, "This was a test. B!") if value != nil
  end
  
  def draw_c(value)
    self.contents.draw_text(20, 0, 100, 32, "This is #{(value == 0)}. C!")
  end

  def draw_d(value)
    self.contents.draw_text(0, 10, 64, 32, value == 0 ? "Hola. D!" : "Adios. D!")
  end
    
  def draw_e(value)
    case (@a_value + @b_value + @c_value - @d_value)
    when 0 then self.contents.draw_text(0, 0, 640, 32, "Fire, E!")
    when 1 then self.contents.draw_text(20, 0, 640, 32, "Ice, E!")
    when 2, 3, 4 then self.contents.draw_text(20, 0, 640, 32, "Water, E!")
    when 5 then self.contents.draw_text(20, 0, 640, 32, "Earth, E!")
    else
      self.contents.draw_text(0, 0, 640, 32, "Darkness or some scary shit, E!")
    end
  end
  
  def draw_f(value)
    self.contents.draw_text(12, 12, 100, 32, "F. Just F.")
  end
end
68 líneas

Seguramente no sean totalmente idénticos sinó que haya algunas diferencias por ejemplo por los nombres de variables o llamadas.
### En el caso de los métodos se puede solucionar usando method("nombre").call
#### En el caso de las variables se puede solucionar usando send("nombre".to_sym)

Y principalmente sería ésto. Hemos pasado de 159 a 68 líneas sin perder información.

Podéis preguntarme cualquier duda.
avatar
Wecoc
Administrador
Administrador



Créditos 9129

Gracias : 471

Volver arriba Ir abajo

Re: [Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Mensaje por orochii el 2013-12-07, 19:59

Yo me sé un truquito que reduce las líneas de tu script instantáneamente.

Mantienes presionada la tecla Control, y mueves la rueda del mouse para atrás. REDUCCIÓN INSTANTÁNEA!!!!1.
===

Buen algoasícomo tutorial,
Orochii Zouveleki
avatar
orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6359

Gracias : 325

http://ragnarokrproject.com/

Volver arriba Ir abajo

Re: [Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Mensaje por youkai el 2013-12-07, 21:09

Si orochii...ese es el mejor truco que hay para eso >:)

Pero volviendo al tema: muy interesante el algoasicomo tutorial pero creeme que yo no usara algo asi...

1 - Reducimos las lineas pero aunque no lo notemos tambien reducimos el performance del mismo.
2 - Revisar ese codigo despues en caso de que haya que hacerle algun cambio/update va a ser un poco tedioso...
3 - Y bueno, ya esto es algo mas personal pero...creeme que cuando programo en lo ultimo que pienso es que en si mi script que se lleva 1253 lineas lo puedo dejar solo en 1000 xDDD

Realmente la parte de la velocidad no es tan critica pero en mi opinion es mejor poner el codigo tal y como es que andar usando Strings, Arrays y metodos de metodos para realizar una accion xD

Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

http://sharingannf.wordpress.com/

Volver arriba Ir abajo

Re: [Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Mensaje por Wecoc el 2013-12-07, 21:36

Si en algunos casos estoy de acuerdo con lo de la performance, pero es que en otros (sobretodo el punto 5) el script puede reducirse a un cuarto de lo que era, y eso es mucho xD. Un ejemplo es un script que hice sobre destreza según arma si mal no recuerdo. Con eso además tienes la ventaja de poder añadir una clase nueva de arma con todos sus def y methods, cambiando solo una array. Aunque parezca que las complica, en ocasiones simplifica bastante las cosas.

Y si has probado de hacer scripts de esos tan largos que ni caben en un solo post, de tropecientas mil líneas como el que hice de AGO finder, verás que ahorrarse líneas pasa a ser más importante.

Pero bueno solo eran truquillos, aplicarlos o no depende de cada uno xDD

PD.- Ah, y en lo de hacer solo un def de todo que puede perder un poco de performance, si interesara no perder los otros def se pueden "enlazar".

por ejemplo:

Código:
def get_weapon(type)
  # montones de cosas
end

def get_sword
  get_weapon("sword")
end

def get_axe
  get_weapon("axe")
end
Jejeje, no se ni qué estoy diciendo.
En fin, ésto es como las lentejas xD
avatar
Wecoc
Administrador
Administrador



Créditos 9129

Gracias : 471

Volver arriba Ir abajo

Re: [Algo así como un Tutorial] Algunos truquillos para reducir las líneas de tus scripts

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.