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 4150 miembros registrados.
El último usuario registrado es Nikerah.

Nuestros miembros han publicado un total de 84841 mensajes en 12081 argumentos.

como calcular el nivel de experiencia que suelta los enemigos.

Ver el tema anterior Ver el tema siguiente Ir abajo

como calcular el nivel de experiencia que suelta los enemigos.

Mensaje por nahured el 2017-07-12, 21:36

hola, ahora estoy utilizando exel para saber la cantidad de experiencia que deberá conseguir mi jugador para llegar a cierto nivel, pero no se que cantidad de experiencia tiene que tirar los enemigos y como calcularlos, ademas de ver como hago la fortaleza de los enemigos.

si saben, me pueden explicar?

Edita Marshmello: Te muevo el tema a "Ayuda RPG", el anterior era para dar consejos para el foro. Revisa bien las secciones antes de publicar.
avatar
nahured
Iniciado
Iniciado

0/3

Créditos 3

Gracias : 2

Volver arriba Ir abajo

Re: como calcular el nivel de experiencia que suelta los enemigos.

Mensaje por sanchez1994 el 2017-07-12, 22:09

Haber yo no tengo mucha experiencia en el tema pero por ejemplo puedes poner que el prota al subir del lv 1 al 2 necesite 1000, del 2 al 3 2000, del 3 al 4 4000, del 4 al 5 8000 , etc a partir de hay puedes poner que el enemigo más débil de 200 , otro mas fuerte que de 500 , más adelante otros que den 1000...
Así lo haría yo pero ya te digo que no tengo mucha experiencia .
avatar
sanchez1994
Principiante
Principiante

0/3

Créditos 110

Gracias : 11

Volver arriba Ir abajo

Re: como calcular el nivel de experiencia que suelta los enemigos.

Mensaje por BreinLand entertainment el 2017-07-14, 01:19

Todo depende de cómo quieres que el jugador viva el juego.
Lo normal es hacer una progresión geométrica en la subida de nivel (lo que viene a ser que multipliques la experiencia del nivel anterior por un valor fijo para hallar la experiencia requerida para el nivel siguiente).

La dificultad, claro está, dependerá de por cuanto lo multipliques, y cuanta experiencia dejen los enemigos.

En el ejemplo de Sanchez, si lo multiplicas por 2 cada vez, necesitarás a nivel 99 un total de
633.825.300.114.114.700.748.351.602.688.000

Vamos... que les matarás a entrenar a no ser que los enemigos dejen mucha experiencia.

Primero tienes que saber la fórmula para calcular valores en la progresión geométrica:

an = a1 × r^(n-1)

an = El número de la serie que quieres obtener
a1 = El primer número de la serie
r = La razón (o el número por el que multiplicarás cada número de la serie para conseguir el siguiente)
n = El número de la serie


Puesto que a nivel 1 la experiencia va a ser 0 (porque empiezas a ese nivel), la serie realmente empieza en el nivel 2. (es el que tomarás como a1).
De esta forma, si quieres obtener el valor del nivel 99, tendrás que restarle 1 (puesto que has movido el primer número de la serie al segundo, moviendo todos los demás), de forma que tu "n" en este caso sería 98 si quisieras calcular el valor del nivel 99.

Sabiendo esto... Planteate qué valor máximo quieres que tenga (más o menos) en experiencia a nivel 99 o el nivel máximo que tengas.

Si quieres que sea un número no redondo, siempre puedes empezar con el primer valor (la experiencia para nivel 2), y luego ver con cuanto acabarías.

Una vez ya sabes la forma de calcular la progresión, lo que te hace falta es pensar si quieres que la experiencia aumente linealmente, o que progresivamente requiera más.




Veamos primero el ejemplo progresivo.

Si queremos que empiece por un número bajo, y cada vez necesite más experiencia, empezando a necesitar 25 para subir a nivel 2, podríamos idear la siguiente fórmula:

an = a1 × (r^0,25)^(n-2) + 25 x (n-3)

Le sumamos 25 a la fórmula para que la subida de los primeros niveles sea relevante (sino sería muy pequeña), y al elevar la razón a 0,25 antes de elevarlo al del número que calculamos, conseguimos una curva de creciente tamaño.

De esta forma, a nivel 3 necesitaríamos 53,72... o redondeando, 54.
A nivel 99 necesitaríamos 17.297.479.

La curva de nivelado quedaría algo parecido a esto:



Si quisiésemos hacerlo menos curvado, solo tendríamos que disminuir el valor al que elevamos "r" un poco. (también disminuiría el valor máximo que necesitamos en experiencia a nivel 99, claro)

Otro ejemplo con r = 2^(0,175)



Donde la experiencia a nivel 3 necesaria sería 53, y la del nivel 99 sería 3.638.287

Claro está, no tiene que ser 2 elevado a algo... pero debe ser mayor a 1 al menos.




Para el ejemplo lineal sería mucho más sencillo.

Solo habría que ir sumando un número fijo, y la dificultad entre niveles sería siempre la misma. (La línea quedaría totalmente recta en la gráfica).

En cuanto a los enemigos... Si utilizas el modo progresivo (que es el que se suele utilizar en todos los juegos), tendrás que pensar en la dificultad del monstruo, y a qué nivel esperas que el jugador llegue ahí.

Puesto que deberás ir haciendo pruebas con el juego... al final más o menos sabrás sobre qué nivel estará el personaje cuando llegue a cada zona. Lo normal es no dar mucha experiencia a los primeros enemigos (entre 5 o 10 de experiencia como mucho) que serán débiles, y dar alrededor de 3-10 veces la experiencia que te daría un enemigo medio para los jefes de la zona.

Para enemigos difíciles tendrás que ajustarlo un poco dependiendo de cómo de difíciles sean, normalmente entre 1,5 o 3 veces el valor de un enemigo normal suele estar bien.

Por último, para las estadísticas de los enemigos, lo suyo es usar de referencia los de tus personajes.

Sabiendo la estadística de tu personaje a tal nivel, un enemigo de nivel igual debería tener estadísticas menores, o como mucho iguales (para enemigos normales).

Para enemigos difíciles, les subes alguna estadística más teniendo de referencia a los normales.

Para jefes... ahí ya a libre elección, aunque es importante tener en cuenta el daño que hace tu personaje al nivel que estimes al que llegará.

Los jefes que deberá hacer sí o sí el jugador NO deberían requerir 1000 golpes para morir.
Entre 20-50 sería algo aceptable... como mucho 100 quizás.

Para los opcionales chungos, ahí ya puedes volverte loco y ponerles de todo (siempre dentro de límites razonables), y si tienen mucha vida, es mejor no ponerles superdefensa (a no ser que se pueda usar alguna estrategia en contra).

El ejemplo más bestia que puedo recordar es en Final fantasy donde los opcionales podían llegar hasta 10 millones de HP, y tu personaje como mucho hasta 99.000 de daño... O lo que es lo mismo, incluso ahí intentan guardar la regla de "no mucho más de 100 golpes".
avatar
BreinLand entertainment
Soñador
Soñador

0/3

Créditos 209

Gracias : 48

Volver arriba Ir abajo

Re: como calcular el nivel de experiencia que suelta los enemigos.

Mensaje por sanchez1994 el 2017-07-14, 04:04

Breinland prefiero que el jugador farmee como un coreano antes que hacer ese cálculo xD, de todas formas yo lo haría así para hasta un máximo de nivel 20-25 nivel 99 me parece muy hardcore en un proyecto de rpg maker.
avatar
sanchez1994
Principiante
Principiante

0/3

Créditos 110

Gracias : 11

Volver arriba Ir abajo

Re: como calcular el nivel de experiencia que suelta los enemigos.

Mensaje por newold el 2017-07-14, 09:27

Código:
#============================================================================================
module Alter_Motion
  
  # ================================ CREDITS ================================================
  # - Galenmereth / Tor Damian Design (Formulas used)
  # - Newold (Script below)
  # =========================================================================================
  
  # ================================ LICENSE ================================================
  # Free for non-commercial use
  # =========================================================================================
  
  #------------------------------------------------------------------------------------------
  #                               Module methods
  #------------------------------------------------------------------------------------------
  
  #------------------------------------------------------------------------------------------
  # * Method self.move (move sprite from A to B)
  #     move_type = Type of movement from Start value to Desired value
  #     t = Current time (frame)
  #     b = Start value
  #     c = Desired change in value
  #     d = Duration total (frames)
  #     intensity = This is the intensity used in a few move_types
  # angle = angle used in parabolic movement
  # vo = initial velocity used in parabolic movement
  # acceleration = acceleration used in parabolic movement
  #     Returns: Value modified by t
  #------------------------------------------------------------------------------------------
  def self.move(move_type,t,b,c,d=20,intensity=1.70158,angle=0,vo=0,acceleration=0.8)
    case move_type
    # ··················································································
    # :linear (default motion)
    when :linear
      return c*t/d.to_f + b
    # ··················································································
    # :back_in, :back_out, :back_in_out
    when :back_in
      s = intensity
      d = d.to_f
      return c*(t/=d)*t*((s+1)*t - s) + b
    when :back_out
      s = intensity
      d = d.to_f
      return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b
    when :back_in_out
      s = intensity
      c = c.to_f
      d = d.to_f
      if ((t/=d/2) < 1)
        return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b
      else
        return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b
      end
    # ··················································································
    # :bounce_in, :bounce_out, :bounce_in_out
    when :bounce_in
      return c - self.move(:bounce_out, d-t, 0, c, d) + b
    when :bounce_out
      if (t/=d.to_f) < (1/2.75)
        return c*(7.5625*t*t) + b
      elsif t < (2/2.75)
        return c*(7.5625*(t-=(1.5/2.75))*t + 0.75) + b
      elsif t < (2.5/2.75)
        return c*(7.5625*(t-=(2.25/2.75))*t + 0.9375) + b
      else
        return c*(7.5625*(t-=(2.625/2.75))*t + 0.984375) + b
      end
    when :bounce_in_out
      if t < d.to_f/2
        return self.move(:bounce_in, t*2, 0, c, d) * 0.5 + b
      else
        return self.move(:bounce_out, t*2-d, 0, c, d) * 0.5 + c*0.5 + b
      end
    # ··················································································
    # :circular_in, :circular_out, :circular_in_out
    when :circular_in
      return -c * (Math.sqrt(1 - (t/=d.to_f)*t) - 1) + b
    when :circular_out
      return c * Math.sqrt(1 - (t=t/d.to_f-1)*t) + b
    when :circular_in_out
      d = d.to_f
      c = c.to_f
      if (t/=d/2) < 1
        return -c/2 * (Math.sqrt(1 - t*t) - 1) + b
      else
        return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b
      end
    # ··················································································
    # :cubic_in, :cubic_out, :cubic_in_out
    when :cubic_in
      t /= d.to_f
      return c*t*t*t + b
    when :cubic_out
      t /= d.to_f
      t -= 1
      return c*(t*t*t + 1) + b
    when :cubic_in_out
      c = c.to_f
      t /= d.to_f/2
      return c/2*t*t*t + b if t < 1
      t -= 2
      return c/2*(t*t*t + 2) + b
    # ··················································································
    # :elastic, :elastic_out, :elastic_in_out
    when :elastic_in
      d=d.to_f
      c=c.to_f
      s=intensity
      p=0
      a=c
      return b if t==0
      return b+c if ((t/=d)==1)
      p=d*0.3 if p==0
      if a < c.abs
        a=c
        s=p/4
      else
        s = p/(2*Math::PI) * Math.asin(c/(a.nonzero? || 1))
      end
      return -(a*(2**(10*(t-=1))) * Math.sin((t*d-s)*(2*Math::PI)/p)) + b
    when :elastic_out
      d=d.to_f
      c=c.to_f
      s=intensity
      p=0
      a=c
      return b if t==0
      return b+c if ((t/=d)==1)
      p = d*0.3 if p==0
      if a < c.abs
        a=c
        s=p/4
      else
        s = p/(2*Math::PI) * Math.asin(c/(a.nonzero? || 1))
      end
      return a*(2**(-10*t)) * Math.sin((t*d-s)*(2*Math::PI)/p) + c + b
    when :elastic_in_out
      d=d.to_f
      c=c.to_f
      s=intensity
      p=0
      a=c
      return b if t==0
      return b+c if ((t/=d/2)==2)
      p=d*(0.3*1.5) if p==0
      if a < c.abs
        a=c
        s=p/4
      else
        s = p/(2*Math::PI) * Math.asin(c/(a.nonzero? || 1))
      end
      return a*(2**(-10*(t-=1))) * Math.sin((t*d-s)*(2*Math::PI)/p)*0.5 + c + b
    # ··················································································
    # :exponential_in, :exponential_out, :exponential_in_out
    when :exponential_in
      return (t==0) ? b : c * (2**(10 * (t/d.to_f - 1))) + b
    when :exponential_out
      return (t==d) ? b+c : c * (-(2**(-10 * t/d.to_f)) + 1) + b
    when :exponential_in_out
      c = c.to_f
      d = d.to_f
      return b if t==0
      return b+c if t==d
      if (t/=d/2) < 1
        return c/2 * (2**(10 * (t - 1))) + b
      else
        return c/2 * (-(2**(-10 * (t-=1))) + 2) + b
      end
    # ··················································································
    # :quad_in, :quad_out, :quad_in_out
    when :quad_in
      t /= d.to_f
      return c*t*t + b
    when :quad_out
      c = c.to_f
      t /= d.to_f
      return -c * t*(t-2) + b;
    when :quad_in_out
      c = c.to_f
      t /= d.to_f/2
      return c/2*t*t + b if t < 1
      t -= 1
      return -c/2 * (t*(t-2) - 1) + b
    # ··················································································
 when :parabolic # by newold
 angle = angle * Math::PI / 180
 x = vo*Math.cos(angle)*t
 y = vo*Math.sin(angle)*t - acceleration*t*t/2
 return x, y
 # ··················································································
    else
      self.move(:linear,t,b,c,d)
    end
  end
  #------------------------------------------------------------------------------------------
  def self.get_time(pi,pf,acceleration,vo)
 # Solve quadratic position function: 0 = (1/2)*a*(t^2) + v_1*t + d1-d2
 t = self.solve_quadratic(0.5*acceleration, vo, [pi[0]-pf[0], pi[1]-pf[1]])
 return t
  end
  #------------------------------------------------------------------------------------------
  def self.solve_quadratic(a, b, c)
 # Method paramters format: Ax² + Bx + C
 solution = []
 discriminant = []
 discriminant << (b * b) - (4 * a * c[0]) # b^2 - 4ac
 discriminant << (b * b) - (4 * a * c[1]) # b^2 - 4ac
 discriminant = discriminant.max
 # Solution 1: (-b + squareroot(b^2 - 4ac)) / 2a
 solution << ((-1 * b) + Math.sqrt(discriminant)) / (2 * a)
 # Solution 1: (-b - squareroot(b^2 - 4ac)) / 2a
 solution << ((-1 * b) - Math.sqrt(discriminant)) / (2 * a)
 return solution.max
  end
  #------------------------------------------------------------------------------------------
 def self.get_movement(move_type, xi, xf, yi, yf, duration, intensity=1.70158,
 ix=0, iy=0, angle=0, vo=0, acceleration=0.8)
 xi = xi.to_f
 xf = xf.to_f
 yi = yi.to_f
 yf = yf.to_f
 duration = duration.to_i
 intensity = intensity.to_f
 ix = ix.to_f
 iy = iy.to_f
 angle = angle.to_f
 vo = vo.to_f
 acceleration = acceleration.to_f
 movement_array = []
 t = 0
 if move_type == :parabolic
 directionX = xi < xf ? -1 : 1
 directionY = yi < yf ? -1 : 1
 angle = Math.atan2(yf-yi,xf-xi)
 duration = self.get_time([xf,yf],[xi,yi],acceleration,vo)
 end
 
 while t < duration
 if move_type != :parabolic
 x = (xi != xf ? self.move(move_type,t,xi,xf,duration,intensity,angle,vo) : 0)
 y = (yi != yf ? self.move(move_type,t,yi,yf,duration,intensity,angle,vo) : 0)
 x += ix if ix != 0
 y += iy if iy != 0
 else
 # movement parabolic (by newold)
 x, y = self.move(move_type,t,nil,nil,nil,nil,angle,vo,acceleration)
 x += xi
 y += yi
 if directionX == -1 and x > xf
 x = xf
 elsif directionX == 1 and x < xf
 x = xf
 end
 if directionY == -1 and y > yf
 y = yf
 elsif directionY == 1 and y < yf
 y = yf
 end
 end
 t += 1
 movement_array << [x,y]
 end
 x = xf + ix.to_f
 y = yf + iy.to_f
 movement_array << [x, y]
 return movement_array
 end
 #------------------------------------------------------------------------------------------
end
#============================================================================================


Te dejo aquí un script para calcular valores. Su uso es sencillo, usa esto:

Código:
=begin

    Tipo de cálculo, pude ser uno de estos valores (incluido los :)
    _in => Aumenta poco al inicio, mucho al final (curva suavizada al principio)
    _out => Amenta mucho al inicio, poco al final (curva suavizada al final)
    _in_out => Curva suavizada al principio y al final
    
    :linear
    :back_in
    :back_out
    :back_in_out
    :bounce_in
    :bounce_out
    :bounce_in_out
    :circular_in
    :circular_out
    :circular_in_out
    :cubic_in
    :cubic_out
    :cubic_in_out
    :elastic_in
    :elastic_out
    :elastic_in_out
    :exponential_in
    :exponential_out
    :exponential_in_out
    :quad_in
    :quad_out
    :quad_in_out
    
=end

# ===========================================
# CONFIGURAR AQUÍ
# ===========================================
tipo = :quad_in # Tipo de cálculo
valor_inicial = 20 # Experiencia para el nivel 2
valor_final = 1850000 # Experiencia para el nivel final
cantidad_valores_devueltos = 97 # Máximo nivel - 2
# FIN CONFIGURACIÓN
# ===========================================

valores = Alter_Motion.get_movement(tipo, valor_inicial, valor_final,
  nil, nil, cantidad_valores_devueltos)
f = File.open("result.txt","wb")
for i in 0...valores.size
  n = (i > 0 ? valores[i][0]-valores[i-1][0] : valores[i][0]).round
  f.puts "Nivel #{i+2}: Exp Necesaria: #{n}, Total: #{valores[i][0].round} Exp."
end
f.close
exit

Lo que hace eso es que te crea un archivo de texto en la carpeta del juego llamado result.txt y dentro te pone la experiencia necesaria para cada nivel según como hayas configurado los valores (los puedes configurar debajo de donde pone CONFIGURAR AQUÍ)

Y ya sabiendo cual es la cantidad de exp que necesitas para pasar de un nivel a otro, puedes decir por ejemplo, pues para subir de nivel necesitas matar 25 enemigos, pues cojes la exp que necesitas para subir de nivel y la divides por 25, y el resultado es lo que deberían dar los enemigos que quieras para que el jugador pueda subir matando 25 de ellos
avatar
newold
Principiante
Principiante

0/3

Créditos 1096

Gracias : 71

Volver arriba Ir abajo

Re: como calcular el nivel de experiencia que suelta los enemigos.

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.