RPG Math Provider

RPGM.lua

local RPGMathProvider = {}
local MFLOOR = math.floor
local s = {}
for key, value in pairs(require(game.Workspace.Settings.PerLevel)) do
	s[key] = value
end
for key, value in pairs(require(game.Workspace.Settings.Starting)) do
	s[key] = value
end
for key, value in pairs(require(game.Workspace.Settings.AttributeEffect)) do
	s[key] = value
end
for key, value in pairs(require(game.Workspace.Settings.Caps)) do
	s[key] = value
end
for key, value in pairs(require(game.Workspace.Settings.Others)) do
	s[key] = value
end
for key, value in pairs(require(game.Workspace.Settings.PVP)) do
	s[key] = value
end
local LTGRD = s.LevelsToGainRangedDamage
local RDPGL = s.RangedDamagePerGainLvl
local DTGRD = s.DexToGainRangedDamage
local RDPGD = s.RangedDamagePerGainDexterity


local LTISD = s.LevelsToIncreaseSwordDamage
local SDPGL = s.SwordDamagePerGainLvl
local STISD = s.StrengthToIncreaseSwordDamage
local SDPGS = s.SwordDamagePerGainStr
math.randomseed(tick())
local MRANDOM = math.random
RPGMathProvider.Combat = {
	RangedPower = function(lvl,attr,offset)
		return (((attr / DTGRD) * RDPGD) + MFLOOR((lvl / LTGRD) * RDPGL)) + offset
	end,
	HeadshotOffset = function(Damage,HeadshotDamageMagnitude)
		 return  Damage  * (HeadshotDamageMagnitude * 0.01)
	end,
	MeleePower = function(lvl, str)
		return MFLOOR((lvl / LTISD) * SDPGL) + MFLOOR((str / STISD) * SDPGS)
	end,
	Hit = function(dex)
		local chance = s.BaseHitChance + ((s.HitChanceDexMagnitude / 100) * dex)
		if chance > s.HitChanceCap then
			return s.HitChanceCap
		end
		return chance
	end;
	Critical = function(dex)
		local chance = s.BaseCritChance + ((s.CritChanceDexMagnitude / 100) * dex)
		if chance > s.CritChanceCap then
			return s.CritChanceCap
		end
		return chance
	end,
	Melee = {
		MinDamage = function(MinDmg,Strength,lvl)
			return MinDmg + MFLOOR(Strength * 0.5) + RPGMathProvider.Combat.MeleePower(lvl, Strength)
		end;
		MaxDamage = function(MaxDmg,Strength,lvl)
			return MaxDmg + MFLOOR(Strength * 0.5) + RPGMathProvider.Combat.MeleePower(lvl, Strength)
		end;
		Damage = function(MinDmg,MaxDmg,lvl)
			return MRANDOM(MinDmg,MaxDmg) + MFLOOR(lvl * 0.2)
		end;
	};
}
RPGMathProvider.MaxStamina = function(plr)
	return (s.StartingSP + (plr.leaderstats.Lvl.Value * s.SPPerLevel) + (plr.attributes.Constitution.Value * s.SPPerConstitution))
end
RPGMathProvider.MobCombatMath = {
	["Regular"] ={
		[1] = function(dmg,Humanoid)
		 	return MFLOOR(dmg * (1 - (game.Players:GetPlayerFromCharacter(Humanoid.Parent).Stats.Defense.Value * 0.01)))
		end,
		[2] = function(dmg,Humanoid)
			if game.Players:GetPlayerFromCharacter(Humanoid.Parent) then
		 return 	MFLOOR(dmg - (game.Players:GetPlayerFromCharacter(Humanoid.Parent).Stats.Defense.Value))
			else
				return dmg
				end
		end
	},
	["Crit"] = function(dmg,CritMagnitude)
		return MFLOOR(dmg * (CritMagnitude * 0.01))
	end,
	["Random"] = {
		["DamageRoll"] = function(ld,hd)
			return MRANDOM(ld,hd)
		end
		
	}
}
RPGMathProvider.PlayerCombatMath = {
	["Regular"] = {
		[1] = function(damage,character)
			return MFLOOR(damage * (1 - (game.Players:GetPlayerFromCharacter(character).Stats.Defense.Value * 0.01)))
		end,
		[2] = function(damage,character)
			return MFLOOR(damage - game.Players:GetPlayerFromCharacter(character).Stats.Defense.Value)
		end
	},
	["BladeCrit"] = function(damage,CritMagnitude)
		return  damage * (CritMagnitude * 0.01)
	end
}
RPGMathProvider.StaffCombatMath = function(BaseDamage,AdditionPerIntelligence,IntelligenceBetweenGains,vPlayer,Offset)
	return BaseDamage.Value + MFLOOR((AdditionPerIntelligence.Value / IntelligenceBetweenGains.Value) * vPlayer.attributes.Intelligence.Value) + MRANDOM(-Offset.Value, Offset.Value)
end
RPGMathProvider.ForcePowerCombatMath = function(BaseDamage,AdditionPerIntelligence,vPlayer,Offset)
	return 	BaseDamage.Value + (AdditionPerIntelligence.Value * vPlayer.attributes.Intelligence.Value) + MRANDOM(-Offset.Value, Offset.Value)

end
RPGMathProvider.ForceMath = {
	EffectTick = function(Timer,EffectTimer)
		return Timer + EffectTimer
	end,
	RemainingForcePoints = function(Mana,ManaCost)
		return  Mana - ManaCost
	end,
	ForceStunDecayRate = function(Qty,Magnitude)
		return Qty * (1 - (Magnitude * 0.1))

	end,
	ForceStunGrowthRate = function(Qty,Magnitude)
		return Qty / (1 - (Magnitude * 0.1))
	end;
	PowerEffect = function(base,AddPerInt,Offset,Int)
		return base + (AddPerInt * Int) + MRANDOM(-Offset,Offset)
	end
}
RPGMathProvider.RangedCombatMath = {

	TorsoDamage = function(Player,Damage,AttributeEffect,PerLevel)
		return (Damage + MFLOOR(Player.attributes.Dexterity.Value / AttributeEffect.DexToGainRangedDamage) * AttributeEffect.RangedDamagePerGainDexterity + math.floor(Player.leaderstats.Lvl.Value / PerLevel.LevelsToGainRangedDamage) * PerLevel.RangedDamagePerGainLvl)
	end,
	HeadShotDamageAI = function(Damage,HeadshotDamageMagnitude)
		return  Damage  * (HeadshotDamageMagnitude * 0.01)
	end,
	TorsoDamageAI = function(Damage,BOT,AttributeEffect,PerLevel)
		return  Damage + MFLOOR(BOT.Attributes.Dexterity / AttributeEffect.DexToGainRangedDamage) * AttributeEffect.RangedDamagePerGainDexterity + MFLOOR(BOT.Lvl / PerLevel.LevelsToGainRangedDamage) * PerLevel.RangedDamagePerGainLvl
	end,
	RegularDamageAI = function(Damage,BOT,AttributeEffect,PerLevel)
		return  Damage + MFLOOR(BOT.Attributes.Dexterity / AttributeEffect.DexToGainRangedDamage) * AttributeEffect.RangedDamagePerGainDexterity + MFLOOR(BOT.Lvl / PerLevel.LevelsToGainRangedDamage) * PerLevel.RangedDamagePerGainLvl
	end,
--	RegularDamage = function(Damage,Player,AttributeEffect,PerLevel)
--		return  Damage + MFLOOR(Player.attributes.Dexterity.Value / AttributeEffect.DexToGainRangedDamage) * AttributeEffect.RangedDamagePerGainDexterity + math.floor(Player.leaderstats.Lvl.Value / PerLevel.LevelsToGainRangedDamage) * PerLevel.RangedDamagePerGainLvl
--	end,
	MaxBoltVelocity = function(PerLevel,plr,AttributeEffect,Velocity)
		return Velocity + (plr.leaderstats.Lvl.Value  * PerLevel.RangedVelocityPerLevel) + (plr.attributes.Dexterity.Value * AttributeEffect.RangedVelocityPerDexterity)
	end
	
}
RPGMathProvider.RegeneratedStamina = function(Others,Player)
	return Player.Stats.Stamina.Value + Others.StaminaRegenRate
end
RPGMathProvider.Modifiers = {
	Crit = function(Starting,vPlayer,AttributeEffect)
		return Starting.BaseCritChance + (vPlayer.attributes.Dexterity.Value * (AttributeEffect.CritChanceDexMagnitude * 0.01))
	end,
	Hit = function(Starting,vPlayer,AttributeEffect)
		return Starting.BaseHitChance + (vPlayer.attributes.Dexterity.Value * (AttributeEffect.HitChanceDexMagnitude/100))
	end,
	SwordCritDamage = function(SwordStats,damage)
		return  damage * (SwordStats.CritMagnitude * 0.01)
	end
}
RPGMathProvider.EXP = {
	linear = function(PerLevel,Others,lvl)
		return (PerLevel.XPPerLevel * lvl) + Others.AdditionalXPNeeded
	end,
	square = function(PerLevel,Others,lvl)
		return PerLevel.XPPerLevel * (lvl * lvl) + Others.AdditionalXPNeeded
	end,
	exponent = function(PerLevel,Others,lvl)
		return (Others.XPExponentMagnitude / 100 ^ (lvl - 1))
		       * PerLevel.XPPerLevel + Others.AdditionalXPNeeded
	end
}
RPGMathProvider.TotalXP = function(XPVal,Lvl)
	local result = 0 
	for i = 1, Lvl do
		result = result + (s.XPPerLevel * i + s.AdditionalXPNeeded)
	end
	result = result + XPVal
	return result
end
RPGMathProvider.Mana = function(level,Intelligence)
	return (s.StartingMP) + RPGMathProvider.ManaBonus(Intelligence.Value,level.Value)
end
RPGMathProvider.HealthBonus = function(con,lvl)
	return (s.HPPerConstitution * con) + (s.HPPerLevel * lvl)
end
RPGMathProvider.ManaBonus = function(int,lvl)
	return (s.MPPerIntelligence * int) + (s.MPPerLevel * lvl)
end
RPGMathProvider.MaxHP = function(level,Constitution)
	return (s.StartingHP) + RPGMathProvider.HealthBonus(Constitution.Value,level.Value)
end
RPGMathProvider.MaxHPWithDefense = function(level,Constitution,Def)
	return RPGMathProvider.MaxHP(level,Constitution) + Def.Value
end
function RPGMathProvider:GetRoll(d,u)
			return MRANDOM(d,u)
end
RPGMathProvider.PVP = {
	PVPLevelMinimum = function(lvl)
		return lvl - s.PvPLevelRange 
	end;
	PVPLevelMaximum = function(lvl)
		return lvl + s.PvPLevelRange
	end
}
function RPGMathProvider:GetDailyLoginBonus(level,Charisma)
	return (s.StartingDLP) + (s.DLPPerLevel * level.Value) + (s.DLPPerCharisma * Charisma.Value)
end
function RPGMathProvider:GetStartingAttributePoints(level)
	return MFLOOR((level / s.LevelsToGainPoints) * s.PointGainIncrement) + s.StartingAttributePoints
end
function RPGMathProvider:GetCreditsPerLevel(level,charisma)
	return (s.StartingCreditsPerLevel) + (s.CreditsPerLevel * level) + (s.CreditsPerCharisma * charisma)
end
return RPGMathProvider