EXPERIENCE GAINED

# ==============================
# Level-Modified Experience v1.0
# by GreatRedSpirit
# ==============================
# Gives actors an experience boost/penalty based on their level and the
# max/min levels of an enemy. If an actor is above an enemy's max level then
# the actor gets an experience penalty based on EXP_PENALTY_MULTIPLIER and the
# number of levels the actor is above max level. It works the same when the
# actor's level is below min level except it uses EXP_BOOST_MULTIPLIER.
#
# To set an enemy's max/min level, add the strings in the enemy note:
# For min level:
# MinimumLevel X
# For max level
# MaximumLevel X
# Where X is a positive number. You can change what strings are looked for
# in EXP_BOOST/PENALTY_REGEX as long as the first value matched is X and
# the string is a regular expression.
#
# The system tries to arrange enemies when calculating experience so that the
# actor gets as much experience as possible. The algorithm is pretty weak for
# it so I'll try and improve it for later iterations.
#
# Known bugs: An actor will get multiple level up messages if multiple enemies
# give the actor levels each.

# Constants:
# Experience boost when level is below an enemy's minimum level
# EXP = exp * boost ^ levels below minimum
EXP_BOOST_MULTIPLIER = 2.00

# Experience penalty given when actor's level is greater than maximum level
# EXP = exp * penalty ^ levels above maximum
EXP_PENALTY_MULTIPLIER = 0.50

# Identifier reg exps to define enemy maximum/minimum levels
# Look for these in the enemy's note
EXP_BOOST_REGEX = "MinimumLevel (+)"
EXP_PENALTY_REGEX = "MaximumLevel (+)"

# Get access to the enemies in the array of the battle troop
# We need this to determine how much experience to get
class Game_Troop < Game_Unit
attr_reader :enemies
end

# Get access to an actor's experience to next level list
# Need this to calculate how much experience an actor gains for level offsets
class Game_Actor < Game_Battler
attr_reader :exp_list
end

# Change the enemy class so the experience it gives is based on an actor's level
class Game_Enemy < Game_Battler
# Give read access to an enemy's min/max level boosts
attr_reader :minLevel,
:maxLevel

# When creating a game enemy, determine the exp boost/penalty levels
alias initialize_ori initialize
def initialize(index, enemy_id)
# Create the enemy first
initialize_ori(index, enemy_id)
# Determine enemy levels, get reference to enemy data:
enemyData = $data_enemies
# See if the minimum level regex is in the enemy note
if enemyData.note =~ EXP_BOOST_REGEX
# Set the enemy's min level to the matched value
@minLevel = $1.to_i
else
# Regex not matched, assume that there's no min level
@minLevel = 0
end
# See if the maximum level regex is in the enemy note
if enemyData.note =~ EXP_PENALTY_REGEX
# Set the enemy's max level to the matched value
@maxLevel = $1.to_i
else
# Regex not matched, assume that there's no max level
@maxLevel = 99999
end
# Sanity check: These values can't cover the same area
# If they do, throw an exception
if @minLevel > @maxLevel
raise Exception.new("Enemy #{enemy.name} has clashing max/min levels")
end
end

# Calculate the amount of experience that should be given to the current actor
alias exp_ori exp
def exp(actor = nil)
# If actor is nil, call the original method
if actor == nil
return exp_ori
end
# There's an actor: Calculate the experience the actor gets and return it
exp = 0 # Experience that can be earned by this enemy for this actor
expPool = exp_ori # Get the total distributable experience
expPool *= 2 if actor.double_exp_gain # Double exp pool if actor has *2 exp
level = actor.level # Current actor level

# Begin experience calculation loop until there's no more experience
while(expPool > 0)
# If the actor is at maximum level
if actor.exp_list <= 0 or actor.exp_list == nil
# Break and give experience
break
end
# Get level difference from max/min level and exp multiplier
# If the actor is below minimum level
if level < @minLevel
levelDif = @minLevel - level
multiplier = EXP_BOOST_MULTIPLIER
# If the actor is above maximum level
elsif level > @maxLevel
levelDif = level - @maxLevel
multiplier = EXP_PENALTY_MULTIPLIER
# Actor is between min/max, multiplier is set to 1.0 and dif to zero
else
levelDif = 0
multiplier = 1.0
end
# Calculate adjusted next level experience
nextLevel = (actor.exp_list * multiplier ** -levelDif).to_i
# If there's enough experience to reach the next level
if expPool > nextLevel
# Assign enough experience to give the actor a level up
exp += nextLevel
# Increase the assigned actor level
level += 1
# Deduct the adjusted next level cost from the pool
expPool -= nextLevel
else
# There wasn't enough experience to level the actor up
# Add the remainder of the experience pool to the earned exp
# (You can always earn one experience per enemy killed)
exp += .max
expPool = 0
end
end
# Return the earned experience
return exp
end

end

# Change how experience is given out:
# For each actor and each enemy defeated, calculate the amount of experience
# that character gets from each enemy based on their current level and

class Scene_Battle < Scene_Base

# Overwrite the level up function so that each actor gets their experience
# from each enemy based on their current level
def display_level_up
#exp = $game_troop.exp_total
for actor in $game_party.existing_members
last_level = actor.level
last_skills = actor.skills
# Build an array for the order to process enemies: Try and be efficient
boostList =
normalList =
penaltyList =
for enemy in $game_troop.enemies
# If the actor gets a boost from this enemy put it here
if actor.level < enemy.minLevel
boostList.push(enemy)
# If the enemy is going to get a exp penalty push him to that list
elsif actor.level > enemy.maxLevel
penaltyList.push(enemy)
# No boost/penalty, add him to the normal list
else
normalList.push(enemy)
end
end
# Combine the lists
enemyList = boostList + normalList + penaltyList
# Run through the new list
for enemy in enemyList
# For the current enemy get all experience
exp = enemy.exp(actor)
actor.gain_exp(exp, true)
end
end
wait_for_message
end

end