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

Nuestros miembros han publicado un total de 84153 mensajes en 11990 argumentos.

(XP)(SCRIPT) Funciones elementales

Ver el tema anterior Ver el tema siguiente Ir abajo

(XP)(SCRIPT) Funciones elementales

Mensaje por jugito08 el 2010-01-29, 12:34

Este script permite usar varias funciones elementales, como subir el daño que causas por elemento, o lo que cuesta usar una habilidad de ese elemento. También incluye elementos opuestos.

Este script es para usar ``funciones elementales´´
Ej:
Agua->Fuego->Planta->nose xD,ect.

Código:
#--------------------------------------------------------------------------
  # Element Affinity
  # Script by Fomar0153
  #--------------------------------------------------------------------------
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # Constantes
  #--------------------------------------------------------------------------
  Elements = [
{'name'=>'Fire', 'id'=>1, 'opp'=>'Ice'},
{'name'=>'Ice', 'id'=>2, 'opp'=>'Fire'},
{'name'=>'Thunder', 'id'=>3, 'opp'=>'Water'},
{'name'=>'Water', 'id'=>4, 'opp'=>'Thunder'},
{'name'=>'Earth', 'id'=>5, 'opp'=>'Wind'},
{'name'=>'Wind', 'id'=>6, 'opp'=>'Earth'},
{'name'=>'Light', 'id'=>7, 'opp'=>'Darkness'},
{'name'=>'Darkness', 'id'=>8, 'opp'=>'Light'}
]
  # El máximo de afinidad con un elemento
  Max_Affinity = 1000
  # El mÃ*nimo de afinidad con un elemento
  Min_Affinity = -1000
  # La afinidad que ganas al usar un elemento
  Element_Usage = 1
  # Cuanta afinidad pierde con el elemento opuesto
  Opposite_Cost = 1
  # La afinidad que se pierde con los demás elementos
  All_Cost = 0
  # La afinidad que necesitas con un elemento para que el hechizo cueste la mitad
  # Nota: 0 significa que la función no ocurre
  Half_Spell_Cost = 250
  # La afinidad que necesitas con un elemento para que el hechizo cueste un cuarto
  # Nota: 0 significa que la función no ocurre
  Quarter_Spell_Cost = 750
  # La afinidad que necesitas con un elemento para causar doble daño
  # Nota: 0 significa que la función no ocurre
  Double_Spell_Damage = 500
  # La afinidad que necesitas con un elemento para causar daño cuádruple
  # Nota: 0 significa que la función no ocurre
  Quad_Spell_Damage = 1000
  # La afinidad hasta la que la habilidad cuesta el doble
  # Nota: 0 significa que la función no ocurre
  Double_Spell_Cost = -250
  # La afinidad hasta la que la habilidad cuesta el cuádruple
  # Nota: 0 significa que la función no ocurre
  Quad_Spell_Cost = -750
  # La afinidad hasta la que la habilidad causa la mitad de daño
  # Nota: 0 significa que la función no ocurre
  Half_Spell_Damage = -500
  # La afinidad hasta la que la habilidad causa un cuarto del daño
  # Nota: 0 significa que la función no ocurre
  Quarter_Spell_Damage = -1000
  # Si está en true tu afinidad afectará positivamente a tu resistencia elemental (> 0)
  Affect_Resistences_Pos = true
  # Si está en true tu afinidad afectará negativamente a tu resistencia elemental (< 0)
  Affect_Resistences_Neg = true
  #--------------------------------------------------------------------------
  # Fin de las Constantes
  #--------------------------------------------------------------------------
  alias old_setup setup
  def setup(actor_id)
    old_setup(actor_id)
    @element_affinity = []
    for i in 0...Elements.size
      @element_affinity.push(0)
    end
  end
 
  def is_element?(element)
    for i in 0...Elements.size
      hash = Elements[i]
      if hash['id'] == element
        return true
      end
    end
    return false
  end
 
  def element_affinity_adjust(element)
    if is_element?(element)
      for i in 0...Elements.size
        hash = Elements[i]
        if hash['id'] == element
          k = i
          opp_name = hash['opp']
        end
      end
     
      for i in 0...Elements.size
        hash = Elements[i]
        if hash['name'] = opp_name
          j = i
        end
      end
      if @element_affinity[k] < Max_Affinity
        @element_affinity[k] += Element_Usage
      end
     
      if @element_affinity[k] > Max_Affinity
        @element_affinity[k] = Element_Usage
      end
     
     
      if @element_affinity[j] > Min_Affinity
        @element_affinity[j] -= Opposite_Cost
      end
     
      if @element_affinity[j] < Min_Affinity
        @element_affinity[j] = Opposite_Cost
      end
     
      unless All_Cost == 0
        for i in 0...Elements.size
          Elements[i] -= All_Cost
        end
        Elements[k] += All_Cost
        Elements[j] += All_Cost
      end
     
    end
  end
   
  def affinity(element)
    if is_element?(element)
      for i in 0...Elements.size
        hash = Elements[i]
        if hash['id'] == element
          return @element_affinity[i]
        end
      end
    end
    return 0
  end
 
  def element_rate(element_id)
    # Da los valores correspondientes a la efectividad de cada elemento
    table = [0,200,150,100,50,0,-100]
    result = table[$data_classes[@class_id].element_ranks[element_id]]
    # Por cada 1% de afinidad máxima consigues +2 de Resistencia
    # lo que significa que al 50% no recibes daño, y al 100%
    # absorbes el daño (asumiendo que empiezas en C (100)
    if is_element?(element_id)
      x = affinity(element_id)
      x /= Max_Affinity
      x *= 200
      if x > 0 and Affect_Resistences_Pos == true
        result -= x
      end
      if x < 0 and Affect_Resistences_Neg == true
        result -= x/2
      end
    end
    # Si el elemento se proteje con armadura, se reduce a la mitad
    for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
      armor = $data_armors[i]
      if armor != nil and armor.guard_element_set.include?(element_id)
        result /= 2
      end
    end
    # Si el elemento se proteje con estado, se reduce a la mitad
    for i in @states
      if $data_states[i].guard_element_set.include?(element_id)
        result /= 2
      end
    end
    # Fin del Método
    return result
  end
   
  def half_spell_cost_is
    return Half_Spell_Cost
  end
 
  def quarter_spell_cost_is
    return Quarter_Spell_Cost
  end
 
  def double_spell_damage_is
    return Double_Spell_Damage
  end
 
  def quad_spell_damage_is
    return Quad_Spell_Damage
  end
   
  def double_spell_cost_is
    return Double_Spell_Cost
  end
 
  def quad_spell_cost_is
    return Quad_Spell_Cost
  end
 
  def half_spell_damage_is
    return Half_Spell_Damage
  end
 
  def quarter_spell_damage_is
    return Quarter_Spell_Damage
  end
 
  def is_actor?
    return true
  end
 
end
class Game_Enemy < Game_Battler
  def is_actor?
    return false
  end
end
class Game_Battler
  def skill_effect(user, skill)
    # Clear critical flag
    self.critical = false
    # If skill scope is for ally with 1 or more HP, and your own HP = 0,
    # or skill scope is for ally with 0, and your own HP = 1 or more
    if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or
      ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1)
      # End Method
      return false
    end
    # Clear effective flag
    effective = false
    # Set effective flag if common ID is effective
    effective |= skill.common_event_id > 0
    # First hit detection
    hit = skill.hit
    if skill.atk_f > 0
      hit *= user.hit / 100
    end
    hit_result = (rand(100) < hit)
    # Set effective flag if skill is uncertain
    effective |= hit < 100
    # If hit occurs
    if hit_result == true
      # Calculate power
      power = skill.power + user.atk * skill.atk_f / 100
      if power > 0
        power -= self.pdef * skill.pdef_f / 200
        power -= self.mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      # Calculate rate
      rate = 20
      rate += (user.str * skill.str_f / 100)
      rate += (user.dex * skill.dex_f / 100)
      rate += (user.agi * skill.agi_f / 100)
      rate += (user.int * skill.int_f / 100)
     
      # For you merging this only the code in this method that is new
      if user.is_actor? and skill.element_set != []
       
        for i in skill.element_set
          affinity = user.affinity(i)
         
          if affinity >= user.double_spell_damage_is and user.double_spell_damage_is != 0
            rate *= 2
          end
         
          if affinity >= user.quad_spell_damage_is and user.quad_spell_damage_is != 0
            rate *= 2
          end
         
          if affinity <= user.half_spell_damage_is and user.half_spell_damage_is != 0
            rate /= 2
          end
         
          if affinity <= user.quarter_spell_damage_is and user.quarter_spell_damage_is != 0
            rate /= 2
          end
         
        end
      end
     
      # Calculate basic damage
      self.damage = power * rate / 20
      # Element correction
      self.damage *= elements_correct(skill.element_set)
      self.damage /= 100
      # If damage value is strictly positive
      if self.damage > 0
        # Guard correction
        if self.guarding?
          self.damage /= 2
        end
      end
      # Dispersion
      if skill.variance > 0 and self.damage.abs > 0
        amp = [self.damage.abs * skill.variance / 100, 1].max
        self.damage += rand(amp+1) + rand(amp+1) - amp
      end
      # Second hit detection
      eva = 8 * self.agi / user.dex + self.eva
      hit = self.damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      hit = self.cant_evade? ? 100 : hit
      hit_result = (rand(100) < hit)
      # Set effective flag if skill is uncertain
      effective |= hit < 100
    end
    # If hit occurs
    if hit_result == true
      # If physical attack has power other than 0
      if skill.power != 0 and skill.atk_f > 0
        # State Removed by Shock
        remove_states_shock
        # Set to effective flag
        effective = true
      end
      # Substract damage from HP
      last_hp = self.hp
      self.hp -= self.damage
      effective |= self.hp != last_hp
      # State change
      @state_changed = false
      effective |= states_plus(skill.plus_state_set)
      effective |= states_minus(skill.minus_state_set)
      # If power is 0
      if skill.power == 0
        # Set damage to an empty string
        self.damage = ""
        # If state is unchanged
        unless @state_changed
          # Set damage to "Miss"
          self.damage = "Fallo"
        end
      end
    # If miss occurs
    else
      # Set damage to "Miss"
      self.damage = "Fallo"
    end
    # If not in battle
    unless $game_temp.in_battle
      # Set damage to nil
      self.damage = nil
    end
    # End Method
    return effective
  end
end
class Window_Skill < Window_Selectable
 
  def draw_item(index)
    skill = @data[index]
    if @actor.skill_can_use?(skill.id)
      self.contents.font.color = normal_color
    else
      self.contents.font.color = disabled_color
    end
    x = 4 + index % 2 * (288 + 32)
    y = index / 2 * 32
    rect = Rect.new(x, y, self.width / @column_max - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    bitmap = RPG::Cache.icon(skill.icon_name)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
    sp_cost = skill.sp_cost
   
    unless skill.element_set == []
      for i in skill.element_set
        affinity = @actor.affinity(i)
        if affinity >= @actor.half_spell_cost_is and @actor.half_spell_cost_is != 0
          sp_cost /= 2
        end
       
        if affinity >= @actor.quarter_spell_cost_is and @actor.quarter_spell_cost_is != 0
          sp_cost /= 2
        end

        if affinity <= @actor.double_spell_cost_is and @actor.double_spell_cost_is != 0
          sp_cost *= 2
        end
       
        if affinity <= @actor.quad_spell_cost_is and @actor.quad_spell_cost_is != 0
          sp_cost *= 2
        end
       
      end
    end
   
   
    self.contents.draw_text(x + 232, y, 48, 32, sp_cost.to_s, 2)
  end
 
end
class Scene_Battle
  def make_skill_action_result
    # Get skill
    @skill = $data_skills[@active_battler.current_action.skill_id]
    # If not a forcing action
    unless @active_battler.current_action.forcing
      # If unable to use due to SP running out
      unless @active_battler.skill_can_use?(@skill.id)
        # Clear battler being forced into action
        $game_temp.forcing_battler = nil
        # Shift to step 1
        @phase4_step = 1
        return
      end
    end
    # Use up SP
    sp_cost = @skill.sp_cost
    if @active_battler.is_actor? and @skill.element_set != []
     
      for i in @skill.element_set
        affinity = @active_battler.affinity(i)
       
        if affinity >= @active_battler.half_spell_cost_is and @active_battler.half_spell_cost_is != 0
          sp_cost /= 2
        end
       
        if affinity >= @active_battler.quarter_spell_cost_is and @active_battler.quarter_spell_cost_is != 0
          sp_cost /= 2
        end

        if affinity <= @active_battler.double_spell_cost_is and @active_battler.double_spell_cost_is != 0
          sp_cost *= 2
        end
       
        if affinity <= @active_battler.quad_spell_cost_is and @active_battler.quad_spell_cost_is != 0
          sp_cost *= 2
        end
      end
    end
    @active_battler.sp -= sp_cost
    # Refresh status window
    @status_window.refresh
    # Show skill name on help window
    @help_window.set_text(@skill.name, 1)
    # Set animation ID
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    # Set command event ID
    @common_event_id = @skill.common_event_id
    # Set target battlers
    set_target_battlers(@skill.scope)
    # Apply skill effect
    for target in @target_battlers
      target.skill_effect(@active_battler, @skill)
    end
   
    if @active_battler.is_actor? and @skill.element_set != []
      for i in @skill.element_set
        @active_battler.element_affinity_adjust(i)
      end
    end
   
   
  end
 
end

Esta muy bueno para los que le interesa haser su juego perfecto gcool .
avatar
jugito08
Iniciado
Iniciado

0/3

Créditos 46

Gracias : 3

http://jugito10.creatuforo.com

Volver arriba Ir abajo

Re: (XP)(SCRIPT) Funciones elementales

Mensaje por orochii el 2010-01-29, 19:08

Ummmm otra utilidad traída por jugito a MM :D, es un script interesante.

Excelente aporte jugito, y felicitaciones a Fomar0153 por el excelente script,
Orochii Zouveleki
avatar
orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6360

Gracias : 325

http://ragnarokrproject.com/

Volver arriba Ir abajo

Re: (XP)(SCRIPT) Funciones elementales

Mensaje por jugito08 el 2010-01-29, 21:49

Me gusta aportar :D,pedime algun spript y te lo consigo si puedo xD.
avatar
jugito08
Iniciado
Iniciado

0/3

Créditos 46

Gracias : 3

http://jugito10.creatuforo.com

Volver arriba Ir abajo

Re: (XP)(SCRIPT) Funciones elementales

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.