[XP] Need help with Hunger/Thirst system by Zero[Resolved]

Started by TsunamiJuri, May 24, 2016, 04:30:00 pm

Previous topic - Next topic

TsunamiJuri

May 24, 2016, 04:30:00 pm Last Edit: December 21, 2016, 03:06:08 am by TsunamiJuri
Edit:
DerVVulfman: Revised it to have a $game_system.hunger_actor value that defines if it applies only to the lead actor or the whole party. At the same time, broke down the methods into smaller parts. At the same time, I saw a bug in the item_effect system he wrote.... fixed it. AND added a special 'patch' that fixes a bug in the map event 'Script Call' feature.

Spoiler: ShowHide
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# Hunger/Thirst
# Initial Author: ForeverZer0
# Date: 5.14.2010 (MM/DD/YYYY)
# Version: 1.0
# Revision Author  DerVVulfman
# Date: 12.20.2016 (MM/DD/YYYY)
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#
#  * Cleaned. Added proper coding throughout the script and fixed script order.
#             Separated the Zer0 module into two separate units, one to handle
#             all configurations and extracted them from clumsy 'methods'.
#             Broken down methods for easier aliasing if new plugins wanted.
#  * Added.   New facility for system to work with only the lead actor.
#             Includes the command_355 'Script System Fix' - Optimal Version.
#
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
#
# Features:
#   - Easy to use
#   - MUCH less complicated than many other similar scripts, yet it has more
#     features and less code
#   - Can have hunger and thirst decrease by time intervals or by steps walked
#     by the player
#   - Ability to have each character's 'Max Hunger' increase so they can go
#     longer in between food and drinks as they gain in power
#   - Can use script calls to easily change hunger/thirst values and to disable
#     the system for long cutscenes, etc. so that nothing decreases while the
#     player does not have control
#   - Automatically added states if hunger/thirst is at specific rates.
#
# Compatibility:
#   - If using Zero Add-On Collection, place this script below it. There is a
#     minor issue with the Chemist Class script, but placing this script below
#     it will solve the problem.
#
# Instructions:
#   - Place script below debug, and above main (below Zer0 Add-Ons, if present)
#   - All configuration is below and described fully in its respective section
#   - The following script calls can be used in game:
#
#    * $game_system.hunger_actor = true
#       - If this script call is used, the system will be set to only affect
#         the lead actor of the party.  If set to false, it affects the entire
#         party.
#
#    *  Zer0.hunger_system(true/false) 
#       - If false, hunger/thirst rates will not decrease. Good for long scenes
#         where the player isn't in control, etc. The system will remain ON/OFF
#         until it is changed.
#
#    *  Zer0.set_hunger(ACTOR_ID, AMOUNT)
#    *  Zer0.set_thirst(ACTOR_ID, AMOUNT)
#       - Sets the hunger/thirst of actor in your database with ACTOR_ID to the
#         number specified by AMOUNT
#
#    *  Zer0.set_max_hunger(ACTOR_ID, AMOUNT)
#    *  Zer0.set_max_thirst(ACTOR_ID, AMOUNT)
#       - Sets the MAX hunger/thirst of actor in your database by ACTOR_ID to
#         the number specified by AMOUNT
#
#    *  Zer0.recover_hunger(ACTOR_ID)
#       - Will recover all hunger/thirst to actor by ACTOR_ID. If you omit the
#         ( ) at the end of the script call, it will recover the entire party.
#
#    *  Zer0.actor_hunger_id(ACTOR_ID)
#       - Returns the current hunger of actor with ACTOR_ID
#
#    *  Zer0.actor_thirst_id(ACTOR_ID)
#       - Returns the current thirst of actor with ACTOR_ID
#
#    *  Zer0.actor_hunger_pos(POSITION)
#       - Return the current hunger of actor at party POSITION
#         (0 is the leader, 1 is actor 2, etc)
#
#    *  Zer0.actor_thirst_pos(POSITION)
#       - Return the current thist of actor at party POSITION
#         (0 is the leader, 1 is actor 2, etc)
#
#    *  Zer0.hunger_debugger
#       - Displays info on-screen of each characters hunger/thirst, current
#         count for steps and time, and shows which features are currently ON.
#
# Special Thanks:
#   - kukusu, whose request gave me the inspiration for the script
#   - SBR*, for pointing out a stupid error I made with the stepcount
#
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=



#==============================================================================
# ** Zer0
#------------------------------------------------------------------------------
#  A module containing ForeverZer0's Hunger/Thirst Configuration Section
#==============================================================================

module Zer0
 
  #--------------------------------------------------------------------------
  FOOD_ITEM       = {}  # Do Not Edit This Line
  STATE_AILMENTS  = {}  # Do Not Edit This Line
  #--------------------------------------------------------------------------


  # DEFAULT HUNGER AND THIRST
  # =========================
  # This sets the base MAX values for the actors.  It can be altered in-game.
  #
    DEFAULT_HUNGER = 100         
    DEFAULT_THIRST = 100         


  # INCREMENT SYSTEM BOOLS
  # ======================
  # This determines if the hunger/thirst system works by calculating the
  # number of steps the player has taken and/or the amount of time that passes.
  # Both may function, however it is suggested to only have one turned on.
  #
    BY_TIME   = true
    BY_STEPS  = true


  # STEPS BEFORE DECREASE
  # Determines how many steps are taken before hunger/thirst decreases.
  # Hunger and thirst decrease by 1 point for each iteration.
  # IE: If STEPS_HUNGER_DOWN is 20, the hunger score reduces 1 per 20 steps.
  #
    STEPS_HUNGER_DOWN = 100 
    STEPS_THIRST_DOWN = 80


  # SECS BEFORE DECREASE
  # Determines how many seconds pass before hunger/thirst decreases.
  # Hunger and thirst decrease by 1 point for each iteration.
  # IE: If SECS_HUNGER_DOWN is 5, the hunger score reduces 1 every 5 seconds.
  #
    SECS_HUNGER_DOWN = 1
    SECS_THIRST_DOWN = 1


  # LEVEL UP INCREASE
  # If enabled, actor's Hunger and thirst scores can increase with each level.
  #
    LVL_UP_INCREASE = true


  # LEVEL UP AMOUNT
  # This defines how many points an actor's Hunger/Thirst can increase with
  # each level (dependant on LVL_UP_INCREASE above).
  #
    LVL_UP_AMOUNT = 5


  # RECOVER BY PERCENTAGE
  # Food items can heal an actor when consumed.  This switch determines if
  # the healing is point based (if false) or is a percentage of the actor's
  # total score (if true)
  #
    RECOVER_BY_PERCENT = true


  # RECOVERY FOOD ITEMS
  # Below you can set food items by ID to sate an actor's hunger and/or thirst.
  # Each item is as follows:  FOOD ITEM[item_id] = [hunger, thirst]
  # Positive hunger or thirst values allow the actor to recover points while
  # negative values can harm the actor, making them hungrier or thirstier.
  #
  # Do NOT have food/drink items do anything other than recover hunger/thirst.
  # Effects such as HP/MP recovery will have no effect.  It is NOT possible to
  # make a healing potion that quenches the actor's thirst.
  #
    FOOD_ITEM[1] = [15,25]
    FOOD_ITEM[2] = [20,35]
    FOOD_ITEM[3] = [25,45]
    FOOD_ITEM[4] = [35,35]
    FOOD_ITEM[5] = [45,45]
    FOOD_ITEM[6] = [95,55]


  # STATE AILMENT RANGE
  # Here, you can set up states that will be applied when an actor's hunger
  # or thirst fall reach a specific point.  This can let you apply states
  # such as 'Starvation' or 'Dehydration'.
  #
  # State ailments are set based upon the point score reached.  If a state
  # ailment is defined as STATE_AILMENTS[5] = [4,6], any actor who has
  # a hunger or thirst score that reached '5' or below will suffer the
  # status effects defined in the array.
  #
  # This method is refreshed every time the system decreases an actor's hunger
  # and thirst score.
  #
  # Keep in mind that these states will not automatically be cured if the
  # actor's hunger/thirst rises above these scores.  Suitable Food/Drink items
  # are needed to cure these states.
  #
  #
    STATE_AILMENTS[0]   = [1,1]
    STATE_AILMENTS[9]   = [2,2]
    STATE_AILMENTS[15]  = [3,3]


end
 

 
#==============================================================================
# ** Zer0
#------------------------------------------------------------------------------
#  A module containing ForeverZer0's Hunger/Thirst calculation methods
#==============================================================================

module Zer0
  #--------------------------------------------------------------------------
  # * Get hunger sate value from food item
  #     item_id : item ID
  #--------------------------------------------------------------------------
  def self.food(item_id)
    return nil unless FOOD_ITEM.has_key?(item_id)
    return FOOD_ITEM[item_id][0]
  end
  #--------------------------------------------------------------------------
  # * Get thirst sate value from food item
  #     item_id : item ID
  #--------------------------------------------------------------------------
  def self.drink(item_id)
    return nil unless FOOD_ITEM.has_key?(item_id)
    return FOOD_ITEM[item_id][1]
  end
  #--------------------------------------------------------------------------
  # * Get status effect ID for Hunger
  #     current_hunger : hunger score
  #--------------------------------------------------------------------------
  def self.hunger_states(current_hunger)
    states = STATE_AILMENTS.sort
    for key in states
      keyval = key[0]
      return key[1][0] if current_hunger <= keyval
    end
    return nil
  end
  #--------------------------------------------------------------------------
  # * Get status effect ID for Thirst
  #     current_thirst : thirst score
  #--------------------------------------------------------------------------
  def self.thirst_states(current_thirst)
    states = STATE_AILMENTS.sort
    for key in states
      keyval = key[0]
      return key[1][1] if current_thirst <= keyval
    end
    return nil
  end
  #--------------------------------------------------------------------------
  # * Set Hunger by value
  #     value : value
  #--------------------------------------------------------------------------
  def self.hunger_system(value)
    $game_party.hunger = value
    return true
  end
  #--------------------------------------------------------------------------
  # * Set actor hunger value
  #     actor_id : Actor ID
  #     amount   : hunger amount
  #--------------------------------------------------------------------------
  def self.set_hunger(actor_id, amount)
    $game_party.actors.each {|a| a.hunger = amount if a.id == actor_id}
  end
  #--------------------------------------------------------------------------
  # * Set actor thirst value
  #     actor_id : Actor ID
  #     amount   : thirst amount
  #--------------------------------------------------------------------------
  def self.set_thirst(actor_id, amount)
    $game_party.actors.each {|a| a.thirst = amount if a.id == actor_id}
  end 
  #--------------------------------------------------------------------------
  # * Set maximum hunger value for actor
  #     actor_id : Actor ID
  #     amount   : new maximum hunger value
  #--------------------------------------------------------------------------
  def self.set_max_hunger(actor_id, amount)
    $game_party.actors.each {|a| a.max_hunger = amount if a.id == actor_id}
  end
  #--------------------------------------------------------------------------
  # * Set maximum thirst value for actor
  #     actor_id : Actor ID
  #     amount   : new maximum thirst value
  #--------------------------------------------------------------------------
  def self.set_max_thirst(actor_id, amount)
    $game_party.actors.each {|a| a.max_thirst = amount if a.id == actor_id}
  end 
  #--------------------------------------------------------------------------
  # * Get actor hunger value
  #     actor_id : Actor ID
  #--------------------------------------------------------------------------
  def self.actor_hunger_id(actor_id)
    $game_party.actors.each {|a| return a.hunger if a.id == actor_id}
  end
  #--------------------------------------------------------------------------
  # * Get actor thirst value
  #     actor_id : Actor ID
  #--------------------------------------------------------------------------
  def self.actor_thirst_id(actor_id)
    $game_party.actors.each {|a| return a.thirst if a.id == actor_id}
  end
  #--------------------------------------------------------------------------
  # * Get party member's hunger value
  #      pos :  game party index value (0 = party leader)
  #--------------------------------------------------------------------------
  def self.actor_hunger_pos(pos = 0)
    return $game_party.actors[pos].hunger if $game_party.actors[pos] != nil
  end
  #--------------------------------------------------------------------------
  # * Get party member's thirst value
  #      pos :  game party index value (0 = party leader)
  #--------------------------------------------------------------------------
  def self.actor_thist_pos(position = 0)
    return $game_party.actors[pos].thirst if $game_party.actors[pos] != nil
  end
  #--------------------------------------------------------------------------
  # * Recover all hunger/thirst for actor
  #     actor_id : Actor ID (or nil for all party member)
  #--------------------------------------------------------------------------
  def self.recover_hunger(actor_id = nil)
    $game_party.actors.each {|actor|
      if actor_id == nil
        actor.hunger = actor.max_hunger
        actor.thirst = actor.max_thirst
      elsif actor.id == actor_id
        actor.hunger = actor.max_hunger
        actor.thirst = actor.max_thirst
      end
    }
  end
  #--------------------------------------------------------------------------
  # * Show Party Hunger/Thirst Values in debugger call
  #--------------------------------------------------------------------------
  def self.hunger_debugger
    sys = "System ON: #{$game_party.hunger}\n\n" +
          "By Time: #{BY_TIME}\n" +
          "By Steps: #{BY_STEPS}\n\n"
    actors = ''
    $game_party.actors.each {|actor| actors +=
      "#{actor.name}\nHunger: #{actor.hunger}\\#{actor.max_hunger}\n" +
      "Thirst: #{actor.thirst}\\#{actor.max_thirst}\n\n"}
    ht = "HungerTime: #{$game_party.time_hunger/40}\\#{SECS_HUNGER_DOWN}\n"
    tt = "ThirstTime: #{$game_party.time_thirst/40}\\#{SECS_THIRST_DOWN}\n"
    hs = "HungerStep: #{$game_party.steps}\\#{$game_party.step_hunger}\n"
    ts = "ThirstStep: #{$game_party.steps}\\#{$game_party.step_thirst}\n"
    print(sys + actors + ht + tt + hs + ts)
  end 
end



#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles data surrounding the system. Backround music, etc.
#  is managed here as well. Refer to "$game_system" for the instance of
#  this class.
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :hunger_actor             # Hunger for Lead Actor Only flag
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias zer0_hunger_initialize initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    zer0_hunger_initialize
    @hunger_actor = false
  end
end



#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
#  This class deals with battlers. It's used as a superclass for the Game_Actor
#  and Game_Enemy classes.
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias zero_hunger_item_effect item_effect
  #--------------------------------------------------------------------------
  # * Application of Item Effects
  #     item : item
  #--------------------------------------------------------------------------
  def item_effect(item)
    food_item   = false
    hunger_plus = Zer0.food(item.id)
    thirst_plus = Zer0.drink(item.id)
    return true if food_item_effect(hunger_plus, thirst_plus) == true
    return zero_hunger_item_effect(item)
  end
  #--------------------------------------------------------------------------
  # * Application of Food Item Effects
  #     hunger_plus : hunger sate effect value
  #     thirst_plus : thirst sate effect value
  #--------------------------------------------------------------------------
  def food_item_effect(hunger_plus, thirst_plus)
    return false unless self.is_a?(Game_Actor)
    food_item   = false
    if hunger_plus != nil
      if Zer0::RECOVER_BY_PERCENT
        hunger_plus = (self.max_hunger * (hunger_plus * 0.01)).ceil
      end
      self.hunger += hunger_plus
      self.hunger = [[self.hunger, self.max_hunger].min, 0].max     
      food_item = true
    end
    if thirst_plus != nil
      if Zer0::RECOVER_BY_PERCENT
        thirst_plus = (self.max_thirst * (thirst_plus * 0.01)).ceil
      end
      self.thirst += thirst_plus
      self.thirst = [[self.thirst, self.max_thirst].min, 0].max
      food_item = true
    end
    return false unless food_item
    states_plus(item.plus_state_set)
    states_minus(item.minus_state_set)
    return true
  end
end



#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :hunger                   # hunger
  attr_accessor :max_hunger               # max hunger
  attr_accessor :thirst                   # thirst
  attr_accessor :max_thirst               # max thirst
  #--------------------------------------------------------------------------
  # * Alias Listings
  #-------------------------------------------------------------------------- 
  alias zer0_hunger_setup setup
  alias zer0_hunger_level_up exp=
  #--------------------------------------------------------------------------
  # * Setup
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  def setup(actor_id)
    zer0_hunger_setup(actor_id)
    @hunger = @max_hunger = Zer0::DEFAULT_HUNGER
    @thirst = @max_thirst = Zer0::DEFAULT_THIRST
    if Zer0::LVL_UP_INCREASE && @level > 1
      increase = Zer0::LVL_UP_AMOUNT
      @hunger = @max_hunger = (@level - 1) * increase + Zer0::DEFAULT_HUNGER
      @thirst = @max_thirst = (@level - 1) * increase + Zer0::DEFAULT_THIRST
    end
  end
  #--------------------------------------------------------------------------
  # * Change EXP
  #     exp : new EXP
  #--------------------------------------------------------------------------
  def exp=(exp)
    level = @level
    zer0_hunger_level_up(exp)
    if Zer0::LVL_UP_INCREASE && level != @level
      lvls = @level - level
      @max_hunger += (Zer0::LVL_UP_AMOUNT * lvls)
      @max_thirst += (Zer0::LVL_UP_AMOUNT * lvls)
    end
  end 
end



#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
#  This class handles the party. It includes information on amount of gold
#  and items. Refer to "$game_party" for the instance of this class.
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :hunger                   # hunger
  attr_accessor :time_hunger              # time hunger
  attr_accessor :time_thirst              # time thirst
  attr_accessor :step_hunger              # step hunger
  attr_accessor :step_thirst              # step thirst
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias zer0_hunger_system_init initialize
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    zer0_hunger_system_init
    @hunger       = true
    @time_hunger  = @time_thirst = 0
    @step_hunger  = Zer0::STEPS_HUNGER_DOWN
    @step_thirst  = Zer0::STEPS_THIRST_DOWN
  end
  #--------------------------------------------------------------------------
  # * Determine Hunger States
  #--------------------------------------------------------------------------
  def check_hunger_states
    if $game_system.hunger_actor == true
      check_actor_hunger_states(@actors[0])
    else
      check_party_hunger_states
    end
  end
  #--------------------------------------------------------------------------
  # * Determine Hunger States for Party
  #--------------------------------------------------------------------------
  def check_party_hunger_states
    @actors.each {|actor|check_actor_hunger_states(actor)}
  end
  #--------------------------------------------------------------------------
  # * Determine Hunger States for Actor
  #     actor : actor
  #--------------------------------------------------------------------------
  def check_actor_hunger_states(actor)
    state_id = Zer0.hunger_states(actor.hunger)
    actor.add_state(state_id) if state_id != nil
  end
  #--------------------------------------------------------------------------
  # * Determine Thirst States
  #--------------------------------------------------------------------------
  def check_thirst_states
    if $game_system.thirst_actor == true
      check_actor_thirst_states(@actors[0])
    else
      check_party_thirst_states
    end
  end
  #--------------------------------------------------------------------------
  # * Determine Hunger States for Party
  #--------------------------------------------------------------------------
  def check_party_thirst_states
    @actors.each {|actor|check_actor_thirst_states(actor)}
  end
  #--------------------------------------------------------------------------
  # * Determine Hunger States for Actor
  #     actor : actor
  #--------------------------------------------------------------------------
  def check_actor_thirst_states(actor)
    state_id = Zer0.thirst_states(actor.thirst)
    actor.add_state(state_id) if state_id != nil
  end
end


#==============================================================================
# ** Interpreter
#------------------------------------------------------------------------------
#  This interpreter runs event commands. This class is used within the
#  Game_System class and the Game_Event class.
#==============================================================================

class Interpreter
  #--------------------------------------------------------------------------
  # * Script
  #--------------------------------------------------------------------------
  def command_355
    # Set first line to script
    script = @list[@index].parameters[0] + "\n"
    # Loop
    loop do
      # If next event command is second line of script or after
      break unless @list[@index+1].code == 655
      # Add second line or after to script
      script += @list[@index+1].parameters[0] + "\n"
      # Advance index
      @index += 1
    end
    # Evaluation
    result = eval(script)
    # If return value is false (must test with false class)
    return false if result == FalseClass
    # Continue
    return true
  end
end



#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # * Alias Listings
  #-------------------------------------------------------------------------- 
  alias zer0_hunger_map_upd update
  #--------------------------------------------------------------------------
  # * Frame Update
  #-------------------------------------------------------------------------- 
  def update
    # The original call
    zer0_hunger_map_upd
    # The hunger/thirst system if turned on
    update_hunger if $game_party.hunger
  end
  #--------------------------------------------------------------------------
  # * Frame Update (hunger/thirst evaluation)
  #-------------------------------------------------------------------------- 
  def update_hunger
    update_hunger_by_time   if Zer0::BY_TIME
    update_hunger_by_steps  if Zer0::BY_STEPS
  end
  #--------------------------------------------------------------------------
  # * Frame Update (handling hunger/thirst by time)
  #-------------------------------------------------------------------------- 
  def update_hunger_by_time
    # Add 1 to hunger and thirst timers
    $game_party.time_hunger += 1
    $game_party.time_thirst += 1
    # Perform if hunger timer reach 40 frames (1 second)
    if $game_party.time_hunger == (Zer0::SECS_HUNGER_DOWN * 40)
      ($game_system.hunger_actor == true) ? hunger_actor : hunger_party
      # Reset timer
      $game_party.time_hunger = 0
    end
    # Perform if thirst timer reach 40 frames (1 second)
    if $game_party.time_thirst == (Zer0::SECS_THIRST_DOWN * 40)
      ($game_system.hunger_actor == true) ? thirst_actor : thirst_party
      # Reset timer
      $game_party.time_thirst = 0
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (handling hunger/thirst by steps)
  #-------------------------------------------------------------------------- 
  def update_hunger_by_steps
    # Perform if hunger steps counter reached
    if $game_party.steps == $game_party.step_hunger
      ($game_system.hunger_actor == true) ? hunger_actor : hunger_party
      # Reset hunger steps
      $game_party.step_hunger = $game_party.steps + Zer0::STEPS_HUNGER_DOWN
    end
    # Perform if thirst steps counter reached
    if $game_party.steps == $game_party.step_thirst
      ($game_system.hunger_actor == true) ? thirst_actor : thirst_party
      # Reset thirst steps
      $game_party.step_thirst = $game_party.steps + Zer0::STEPS_THIRST_DOWN
    end   
  end
  #--------------------------------------------------------------------------
  # * Party Hunger Update
  #-------------------------------------------------------------------------- 
  def hunger_party
    # Cycle through party and handle hunger
    $game_party.actors.each {|actor|
      actor.hunger -= 1 unless actor.dead? || actor.hunger == 0}
    $game_party.check_hunger_states
  end
  #--------------------------------------------------------------------------
  # * Actor Hunger Update
  #-------------------------------------------------------------------------- 
  def hunger_actor
    # Get party leader and handle hunger
    actor = $game_party.actors[0]
    actor.hunger -= 1 unless actor.dead? || actor.hunger == 0
    $game_party.check_hunger_states
  end
  #--------------------------------------------------------------------------
  # * Party Thirst Update
  #-------------------------------------------------------------------------- 
  def thirst_party
    # Cycle through party and handle thirst
    $game_party.actors.each {|actor|
      actor.thirst -= 1 unless actor.dead? || actor.thirst == 0}
    $game_party.check_hunger_states
  end   
  #--------------------------------------------------------------------------
  # * Actor Thirst Update
  #-------------------------------------------------------------------------- 
  def thirst_actor
    # Get party leader and handle thirst
    actor = $game_party.actors[0]
    actor.thirst -= 1 unless actor.dead? || actor.thirst == 0
    $game_party.check_hunger_states
  end 
end


---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
I'm using Zero's Hunger/Thirst System. It works fine but I only want it for the party leader. I saw that someone ask this in the coments, but zero didnt reply. I have tried my best to figure it out. Can someone help me?

Here is my edit. I seperated the Hunger Thirst since they were together everytime I recovered the Hunger.

Spoiler: ShowHide
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Hunger/Thirst
# Author: ForeverZer0
# Date: 5.14.2010
# Version: 1.0
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#
# Features:
#   - Easy to use
#   - MUCH less complicated than many other similar scripts, yet it has more
#     features and less code
#   - Can have hunger and thirst decrease by time intervals or by steps walked
#     by the player
#   - Ability to have each character's 'Max Hunger' increase so that they can go
#     longer in between food and drinks as they gain in power
#   - Can use script calls to easily change hunger/thirst values, and to disable
#     the system for long cutscenes, etc. so that nothing decreases while the
#     player does not have control
#   - Automatically added states if hunger/thirst is at specific rates.
#
# Compatibility:
#   - If using Zero Add-On Collection, place this script below it. There is a
#     minor issue with the Chemist Class script, but placing this script below
#     it will solve the problem.
#
# Instructions:
#   - Place script below debug, and above main (below Zer0 Add-Ons, if present)
#   - All configuration is below and described fully in its respective section
#   - The following script calls can be used in game:
#
#    ?  Zer0.hunger_system(true/false) 
#       - If false, hunger/thirst rates will not decrease. Good for long scenes
#         where the player is not in control, etc. The system will remain ON/OFF
#         until it is changed.
#
#    ?  Zer0.set_hunger(ACTOR_ID, AMOUNT)
#    ?  Zer0.set_thirst(ACTOR_ID, AMOUNT)
#       - Sets the hunger/thirst of actor in your database with ACTOR_ID to the
#         number specified by AMOUNT
#
#    ?  Zer0.set_max_hunger(ACTOR_ID, AMOUNT)
#    ?  Zer0.set_max_thirst(ACTOR_ID, AMOUNT)
#       - Sets the MAX hunger/thirst of actor in your database with ACTOR_ID to
#         the number specified by AMOUNT
#
#    ?  Zer0.recover_hunger(ACTOR_ID)
#       - Will recover all hunger/thirst to actor with ACTOR_ID. If you omit the
#         ( ) at the end of the script call, it will recover the entire party.
#
#    ?  Zer0.actor_hunger_id(ACTOR_ID)
#       - Returns the current hunger of actor with ACTOR_ID
#
#    ?  Zer0.actor_thirst_id(ACTOR_ID)
#       - Returns the current thirst of actor with ACTOR_ID
#
#    ?  Zer0.actor_hunger_pos(POSITION)
#       - Return the current hunger of actor at party POSITION
#         (0 is the leader, 1 is actor 2, etc)
#
#    ?  Zer0.actor_thirst_pos(POSITION)
#       - Return the current thist of actor at party POSITION
#         (0 is the leader, 1 is actor 2, etc)
#
#    ?  Zer0.hunger_debugger
#       - Displays info on-screen of each characters hunger/thirst, current
#         count for steps and time, and shows which features are currently ON.
#
# Special Thanks:
#   - kukusu, whose request gave me the inspiration for the script
#   - SBR*, for pointing out a stupid error I made with the stepcount
#
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:


#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#                          BEGIN CONFIGURATION
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:

module Zer0
 
  DEFAULT_HUNGER = 50           
  DEFAULT_THIRST = 50         
  # Default max hunger/thirst players will begin with. This can be increased as
  # the player becomes more powerful, through items, etc. if desired.
 
  BY_TIME   = true
  BY_STEPS  = true
  # There are two ways hunger and thirst can be calculated; one by just how many
  # seconds pass, and the other by how many steps have been taken. You can use
  # both if you like, but I would suggest that if you do to try to keep it more
  # skewed to one or the other as the main method of decreasing, and use the
  # other as a minor added dynamic.
 
  STEPS_HUNGER_DOWN = 100 
  STEPS_THIRST_DOWN = 80
  # Only if using 'BY_STEPS', otherwise ignore these. These are the amount
  # of steps before hunger/thirst decrease.
 
  SECS_HUNGER_DOWN = 120
  SECS_THIRST_DOWN = 120
  # Only if using 'BY_TIME', otherwise ignore these. These are the amount
  # of seconds before hunger/thirst decrease.
 
  LVL_UP_INCREASE = false
  # If true, will increase max hunger/thirst at each level up, the amount of
  # increase is defined just below.
  LVL_UP_AMOUNT = 0
  # This will be added to the actor's max hunger/thirst at each level up, only
  # if LVL_UP_INCREASE is true.

#-------------------------------------------------------------------------------
# Food/Drink Items:
#
#   Set up your food/drink items recovery rates here. Food and drink are each in
#   their own section. Use this syntax to set them up:
#
#     when ITEM_ID the return RECOVERY_AMOUNT
#
#   For example, in the first example below, it means that the item in your
#   database with ID(1) will cure hunger by 15. If RECOVER_BY_PERCENT (below) is
#   set to true, it will recover 15% of that actors MAX hunger/thirst.
#
#   You can also create items that have negative effects by making the
#   RECOVERY_AMOUNT a negative number. DO NOT have food/drink items do anything
#   other than recover hunger/thirst and/or add/remove states. Anything else,
#   such has HP/MP recovery, will have no effect.
#
#-------------------------------------------------------------------------------

  RECOVER_BY_PERCENT = true
  # Recovery can be by either absolute value, or by percent. Setting this to
  # true will make it by percent.

  def self.food(item_id)
    case item_id
    when 31 then return 10
    when 32 then return 15
    when 43 then return 25
   # when 2 then return 25
   # when 3 then return 35
   # when 4 then return 50
   # when 5 then return 75
   # when 6 then return 100
    end
  end
 
  def self.drink(item_id)
    case item_id
    when 44 then return 25
   # when 2 then return 25
   # when 3 then return 35
   # when 4 then return 50
   # when 5 then return 75
   # when 6 then return 100
    end
  end
 
#-------------------------------------------------------------------------------
# Hunger/Thirst States
#
#   Set up states that will be applied when an actors hunger/thirst fall within
#   a defined range, such as 'Starvation', 'Dehydration', etc.
#   Configure like this:
#
#   when MIN..MAX then return STATE_ID
#
#   If actor's hunger/thirst is equal to or between MIN and MAX, the state with
#   STATE_ID will be applied. This method is refreshed everytime the system
#   decreases hunger/thirst.
#
#   Keep in mind that these states will NOT be automatically cured if the actor's
#   hunger/thirst rise above. Create your food/drink items to cure these states.
#
#-------------------------------------------------------------------------------

  def self.hunger_states(current_hunger)
    case current_hunger
    when 0 then return 19
    when 1..9 then return 19
    when 10..15 then return 20
    end
  end
 
  def self.thirst_states(current_thirst)
    case current_thirst
    when 0 then return 22
    when 1..9 then return 22
    when 10..15 then return 21
    end
  end
     
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#                             END CONFIGURATION
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:HUNGER:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
  def self.hunger_system(value)
    $game_party.hunger = value
    return true
  end

  def self.set_hunger(actor_id, amount)
    $game_party.actors.each {|a| a.hunger = amount if a.id == actor_id}
  end
 
  def self.set_max_hunger(actor_id, amount)
    $game_party.actors.each {|a| a.max_hunger = amount if a.id == actor_id}
  end
 
  def self.actor_hunger_id(actor_id)
    $game_party.actors.each {|a| return a.hunger if a.id == actor_id}
  end
 
  def self.actor_hunger_pos(pos = 0)
    return $game_party.actors[pos].hunger if $game_party.actors[pos] != nil
  end
 
  def self.recover_hunger(actor_id = nil)
    $game_party.actors.each {|actor|
      if actor_id == nil
        actor.hunger = actor.max_hunger
      elsif actor.id == actor_id
        actor.hunger = actor.max_hunger
      end
    }
  end
  #:=:=:=:=:=:=:=:=:=:=:=:=:=:=:THIRST=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
  def self.thirst_system(value)
    $game_party.thrist = value
    return true
  end
 
  def self.set_thirst(actor_id, amount)
    $game_party.actors.each {|a| a.thirst = amount if a.id == actor_id}
  end
 
  def self.set_max_thirst(actor_id, amount)
    $game_party.actors.each {|a| a.max_thirst = amount if a.id == actor_id}
  end
 
  def self.actor_thirst_id(actor_id)
    $game_party.actors.each {|a| return a.thirst if a.id == actor_id}
  end
 
  def self.actor_thist_pos(position = 0)
    return $game_party.actors[pos].thirst if $game_party.actors[pos] != nil
  end
 
  def self.recover_thirst(actor_id = nil)
    $game_party.actor.each {|actor|
      if actor_id == nil
        actor.thirst = actor.max_thirst
      elsif actor.id == actor_id
        actor.thirst = actor.max_thirst
      end
    }
  end
 
  def self.hunger_debugger
    sys = "System ON: #{$game_party.hunger}\n\n" +
          "By Time: #{BY_TIME}\n" +
          "By Steps: #{BY_STEPS}\n\n"
    actors = ''
    $game_party.actors.each {|actor| actors +=
      "#{actor.name}\nHunger: #{actor.hunger}\\#{actor.max_hunger}\n" +
      "Thirst: #{actor.thirst}\\#{actor.max_thirst}\n\n"}
    ht = "HungerTime: #{$game_party.time_hunger/40}\\#{SECS_HUNGER_DOWN}\n"
    tt = "ThirstTime: #{$game_party.time_thirst/40}\\#{SECS_THIRST_DOWN}\n"
    hs = "HungerStep: #{$game_party.steps}\\#{$game_party.step_hunger}\n"
    ts = "ThirstStep: #{$game_party.steps}\\#{$game_party.step_thirst}\n"
    print(sys + actors + ht + tt + hs + ts)
  end
 
end

#-------------------------------------------------------------------------------
# ** Game_Actor (When you level the hunger/thirst values go up)
#-------------------------------------------------------------------------------

class Game_Actor < Game_Battler
 
  attr_accessor :hunger
  attr_accessor :max_hunger
  attr_accessor :thirst
  attr_accessor :max_thirst
 
  alias zer0_hunger_setup setup
  def setup(actor_id)
    zer0_hunger_setup(actor_id)
    @hunger = @max_hunger = Zer0::DEFAULT_HUNGER
    @thirst = @max_thirst = Zer0::DEFAULT_THIRST
    if Zer0::LVL_UP_INCREASE && @level > 1
      increase = Zer0::LVL_UP_AMOUNT
      @hunger = @max_hunger = (@level - 1) * increase + Zer0::DEFAULT_HUNGER
      @thirst = @max_thirst = (@level - 1) * increase + Zer0::DEFAULT_THIRST
    end
  end
 
  alias zer0_hunger_level_up exp=
  def exp=(exp)
    level = @level
    zer0_hunger_level_up(exp)
    if Zer0::LVL_UP_INCREASE && level != @level
      lvls = @level - level
      @max_hunger += (Zer0::LVL_UP_AMOUNT * lvls)
      @max_thirst += (Zer0::LVL_UP_AMOUNT * lvls)
    end
  end 
end

#-------------------------------------------------------------------------------
# ** Game_Battler (How the items work)
#-------------------------------------------------------------------------------

class Game_Battler
 
  alias test item_effect
  def item_effect(item)
    food_item = false
    drink_item = false
    hunger_plus = Zer0.food(item.id)
    thirst_plus = Zer0.drink(item.id)
    if hunger_plus != nil
      if Zer0::RECOVER_BY_PERCENT
        hunger_plus = (self.max_hunger * (hunger_plus * 0.01)).ceil
      end
      self.hunger += hunger_plus
      self.hunger = [[self.hunger, self.max_hunger].min, 0].max     
      food_item = true
    end
    if thirst_plus != nil
      if Zer0::RECOVER_BY_PERCENT
        thirst_plus = (self.max_thirst * (thirst_plus * 0.01)).ceil
      end
      self.thirst += thirst_plus
      self.thirst = [[self.thirst, self.max_thirst].min, 0].max
      drink_item = true
    end
    if food_item
      states_plus(item.plus_state_set)
      states_minus(item.minus_state_set)
      return true
    end
    if drink_item
      states_plus(item.plus_state_set)
      states_minus(item.minus_state_set)
      return true
    end
    test(item)
  end
end

#-------------------------------------------------------------------------------
# ** Game_Party (sets up the system?)
#-------------------------------------------------------------------------------

class Game_Party
 
  attr_accessor :hunger
  attr_accessor :time_hunger
  attr_accessor :time_thirst
  attr_accessor :step_hunger
  attr_accessor :step_thirst
 
  alias zer0_hunger_system_init initialize
  def initialize
    zer0_hunger_system_init
    @hunger = true
    @thirst = true
    @time_hunger = @time_thirst = 0
    @step_hunger = Zer0::STEPS_HUNGER_DOWN
    @step_thirst = Zer0::STEPS_THIRST_DOWN
  end
 
  def check_hunger_states
    @actors.each {|actor|
    state_id = Zer0.hunger_states(actor.hunger)
    actor.add_state(state_id) if state_id != nil}
  end
 
  def check_thirst_states
    @actors.each {|actor|
    state_id = Zer0.thirst_states(actor.thirst)
    actor.add_state(state_id) if state_id != nil}
  end
 
end

#-------------------------------------------------------------------------------
# ** Scene_Map (when your walk or when the time goes down the values decrease)
#-------------------------------------------------------------------------------

class Scene_Map
 
  alias zer0_hunger_map_upd update
  def update
    zer0_hunger_map_upd
    if $game_party.hunger
      update_hunger
    end
  end
 
  def update_hunger
    if Zer0::BY_TIME
      $game_party.time_hunger += 1
      $game_party.time_thirst += 1
      if $game_party.time_hunger == (Zer0::SECS_HUNGER_DOWN * 40)
        $game_party.actors.each {|actor|
          actor.hunger -= 1 unless actor.dead? || actor.hunger == 0}
        $game_party.check_hunger_states
        $game_party.time_hunger = 0
      end
      if $game_party.time_thirst == (Zer0::SECS_THIRST_DOWN * 40)
        $game_party.actors.each {|actor|
          actor.thirst -= 1 unless actor.dead? || actor.thirst == 0}
        $game_party.check_thirst_states
        $game_party.time_thirst = 0
      end
    end
    if Zer0::BY_STEPS
      if $game_party.steps == $game_party.step_hunger
        $game_party.actors.each {|actor|
          actor.hunger -= 1 unless actor.dead? || actor.hunger == 0}
        $game_party.check_hunger_states
        $game_party.step_hunger = $game_party.steps + Zer0::STEPS_HUNGER_DOWN
      end
      if $game_party.steps == $game_party.step_thirst
        $game_party.actors.each {|actor|
          actor.thirst -= 1 unless actor.dead? || actor.thirst == 0}
        $game_party.check_thirst_states
        $game_party.step_thirst = $game_party.steps + Zer0::STEPS_THIRST_DOWN
      end
    end
  end
end