//XP
public override long XpGain(long xpGain, int mod = 1)
{
if (mod < 1)
{
mod = Verify.Min(level, 1);
}
experience += xpGain = NumbersM.CeilParse <long>(Verify.Min((xpGain * ReferenceData.xprate) / mod, 10));
long reqXPToLVL = Quadratic.XPCalc(level + 1);
while (experience >= reqXPToLVL)
{
_ = Handlers.UniqueChannels.Instance.SendMessage("Population", displayName + " leveled up!");
level++;
KCoins += level * 10;
stats.maxhealth += 5;
experience -= reqXPToLVL;
reqXPToLVL = Quadratic.XPCalc(level + 1);
if (role == CombatRole.None && level >= 20)
{
GetCombatRole();
}
if (IsGainSkillPoint())
{
AddStats();
}
}
return(xpGain);
}
internal void ScaleNPC(double mult = 1)
{
double buffPercent =
//level/(double)baseLevel* 2
Exponential.CreatureScale(baseLevel, level)
* mult;
//Stats
stats.maxhealth = NumbersM.CeilParse <long>(stats.maxhealth * (1 + buffPercent * 5));
stats.stamina = NumbersM.CeilParse <int>(stats.stamina * (1 + buffPercent * 2));
health = Health();
stamina = Stamina();
for (int i = 0; i < DmgType.Length; i++)
{
if (stats.damage[i] > 0)
{
stats.damage[i] = NumbersM.CeilParse <long>(stats.damage[i] * (1 + buffPercent / 3));
}
if (stats.resistance[i] > 0)
{
stats.resistance[i] = NumbersM.CeilParse <int>(stats.resistance[i] * (1 + (buffPercent / 5)));
}
}
//Extra Drops
if (Program.rng.Next(101) <= 1)
{
Item tempSchem = SkaviDrops.DropSchematic(race);
if (tempSchem != null)
{
AddItemToInv(tempSchem);
}
}
}
public object[] ReflectiveWard(CombatResult owner, CombatResult target)
{
if (target.SentHit)
{
if (Program.Chance(tier))
{
long totalDamage = 0;
for (int i = 0; i < target.baseDamage.Length; i++)
{
totalDamage += NumbersM.FloorParse <long>
((target.baseDamage[i]
+ target.bonusDamage[i]) *
target.damageMultiplier[i]);
target.damageMultiplier[i] = 0;
}
long returned = NumbersM.FloorParse <long>(totalDamage *
(5.00 + tier) / 100);
target.character.TakeDamage(returned);
owner.perkProcs.Add($"Returned {returned} damage to {target.Name}");
}
}
return(R(owner, target));
}
void RefreshActivityThread()
{
DateTime toEnd = activity.start.AddDays(7);
long time = NumbersM.NParse <long>((toEnd - DateTime.UtcNow).TotalMilliseconds);
ActivityThread((int)time, (int)(time - int.MaxValue));
}
internal long PercentHealing(double percent, bool canOverheal = false)
{
if (percent > 0)
{
return(Healing(NumbersM.NParse <long>(Health() * percent), canOverheal));
}
return(0);
}
internal long PercentHealing(int percent, bool canOverheal = false)
{
if (percent > 0)
{
return(Healing(NumbersM.NParse <long>(Health() * (percent / 100.00)), canOverheal));
}
return(0);
}
internal int GetAreaFloorLevel(Random rng, int floor = -1)
{
double range = 0.20;
int fl = NumbersM.NParse <int>(level * (1 + (floor / (5.00 * level))));
int min = NumbersM.NParse <int>(fl * (1 - range));
int max = NumbersM.NParse <int>(fl * (1 + range));
return(rng.Next(min, max + 1));
}
internal Item ScaleArmor(Item item, int target)
{
double m = ((double)target) / item.tier;
double n = m - 1;
#region Excluded stats
long l = 0;
foreach (int r in item.damage)
{
l += r > 0 ? NumbersM.CeilParse <long>(n * r * damage) : 0;
}
l += NumbersM.CeilParse <long>(
+(item.durability + item.agility
+ Convert.ToInt64(item.critChance)
+ Convert.ToInt64(item.critMult)
+ (item.perk != null ? (item.perk.tier + 1) * perk : 0)
) * n);
#endregion
#region Included Stats
long i =
(item.healthBuff != 0 ? health : 0)
+ (item.staminaBuff != 0 ? stamina : 0);
foreach (var d in item.resistance)
{
i += d != 0 ? resistance : 0;
}
#endregion
//Update stats
item.healthBuff = item.healthBuff != 0 ?
item.healthBuff = NumbersM.CeilParse <long>(
(item.healthBuff * m) +
((health * (l + 0.00) / i) / health)) : 0;
item.staminaBuff = item.staminaBuff != 0 ?
item.staminaBuff = NumbersM.CeilParse <int>(
(item.staminaBuff * m) +
((stamina * (l + 0.00) / i) / stamina)) : 0;
for (int k = 0; k < item.resistance.Length; k++)
{
if (item.resistance[k] != 0)
{
item.resistance[k] = NumbersM.FloorParse <int>(
(item.resistance[k] * m) +
((resistance * (l + 0.00) / i) / resistance));
}
}
return(item);
}
public static string DefeatCost(Player player, NPC mob, double intensity = 1)
{
long xpDropped = NumbersM.NParse <long>(player.XPDrop(mob.level) * intensity);
player.experience -= xpDropped;
long coinsLost = Verify.Max(NumbersM.NParse <long>(((mob.Rank() + mob.level) * 2) * intensity), player.KCoins);
player.KCoins -= coinsLost;
//Log.CombatData(mob, player, xpDropped);
mob.XpGain(xpDropped);
return($"{player.name} lost {xpDropped} XP And {coinsLost} Kuts");
}
static long UpgradeStat(long stat, double increase)
{
if (stat > 0)
{
stat = Verify.Min(NumbersM.FloorParse <long>(stat * increase), stat + 1);
}
else if (stat < 0)
{
stat = Verify.Min(NumbersM.FloorParse <long>(stat * increase), stat - 1);
}
return(stat);
}
static int UpgradeStat(int stat, double increase)
{
if (stat > 0)
{
stat = Verify.Min(NumbersM.FloorParse <int>(stat * increase), stat + 1);
}
else if (stat < 0)
{
stat = Verify.Min(NumbersM.FloorParse <int>(stat * increase), stat - 1);
}
return(stat);
}
//
public string ToolName(string tool, int tier = -1, int level = -1)
{
if (tier < 0)
{
tier = GetTier(tool);
}
if (level < 0)
{
level = GetLevel(tool);
}
return($"{GetAllTiers(tool)[tier]} {NumbersM.GetLevelMark(level)}");
}
public async Task RecruitNPC()
{
Player player = Player.Load(Context.BotUser);
if (!player.IsEncounter("NPC"))
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync($"{player.name} is not in an encounter with an NPC"));
}
else if (player.Party == null)
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync($"{player.name} must be in a Party to recruit an NPC"));
}
else if (player.Party.UpdateFollower(player.Encounter.npc))
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync($"This NPC is already in your party."));
}
else if (player.Encounter.npc.profession == ReferenceData.Profession.Peasant)
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync($"```{Dialog.GetDialog(player.Encounter.npc, Dialog.peasantRecruit)}```"));
}
else if (player.Party.MemberCount >= 4)
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync($"{player.name}'s party is full."));
}
else
{
NPC n = player.Encounter.npc;
if ((player.level * 0.9) - player.stats.GetCHA() > n.level && player.userid != 201875246091993088)
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync(
$"```{Dialog.GetDialog(n, Dialog.weakRecruit)}```"));
}
else
{
long cost = NumbersM.FloorParse <long>(((player.level + player.Rank() + n.level + n.Rank()) * 39)
* (1.00 - (Stats.recruitPricePerCha * player.stats.GetCHA())));
if (player.KCoins < cost)
{
await DUtils.DeleteBothMsg(Context, await ReplyAsync(
$"{player.name} does not have the required coins to recruit {n.displayName}. " +
$"Missing {cost - player.KCoins} from total {cost}"));
}
else
{
await ComfirmRecruitNPC(player, cost, Context.Channel);
}
}
}
}
public object[] SpikedArmor(CombatResult owner, CombatResult enemy)
{
if (enemy.abilityUsed != null && enemy.SentHit &&
enemy.abilityUsed.type == Ability.AType.Martial)
{
long reflectedDamage = NumbersM.NParse <long>(enemy.baseDamage[0] *
Verify.Max(owner.character.stats.GetEND() * 0.01, 0.25));
if (reflectedDamage > 0)
{
enemy.selfDamageTaken[0] += reflectedDamage;
owner.perkProcs.Add($"{owner.Name} returned {reflectedDamage} to {enemy.Name}");
}
}
return(new object[] { owner, enemy });
}
void FollowerCheck(NPC n, Party party, bool allPlayersDead)
{
int s = n.HealthStatus(out string status);
/// >= 0 Is alive
/// -1 is Down, -2 Fainted, -3 Unconscious, -4 Dead, -5 Vaporized
if (s < -1 || allPlayersDead)
{
if (n.IsPet())
{
if (party != null && s <= -4)
{
party.Remove(party.NPCMembers.FindIndex
(x => x.origin == n.origin), null);
}
else
{
n.health = n.Health();
n.stamina = n.Stamina();
}
}
else
{
if (party != null)
{
party.NPCMembers.RemoveAt(party.NPCMembers.FindIndex
(x => x.displayName == n.displayName));
}
if (s > -4)
{
n.Respawn();
}
}
}
else if (s >= -1)
{
long fullHealthCost = Verify.Max(
NumbersM.NParse <long>(100 - (((n.health + 0.00) / n.Health()) * 100))
, n.KCoins);
if (fullHealthCost > 0)
{
n.KCoins -= fullHealthCost;
n.health += NumbersM.CeilParse <long>(n.Health() * (fullHealthCost / 100.00));
}
n.stamina = n.Stamina();
n.SelfGear();
}
}
internal Item ScaleWeapon(Item item, int target)
{
double m = (double)target / item.tier;
double n = m - 1;
long l = 0;
#region Excluded stats
foreach (int r in item.resistance)
{
l += r != 0 ? NumbersM.CeilParse <int>(n * r * resistance) : 0;
}
try
{
l += NumbersM.CeilParse <long>(item.healthBuff * health * n)
+
NumbersM.CeilParse <long>(item.staminaBuff * stamina * n)
+
NumbersM.CeilParse <long>(
(
item.durability + item.agility
+ item.critChance
+ item.critMult
+ (item.perk != null ? (item.perk.tier + 1) * perk : 0)
) * n
);
}
catch (Exception e) { Console.WriteLine("Error in other math"); throw e; }
#endregion
long i = 0;
foreach (var d in item.damage)
{
i += d > 0 ? damage : 0;
}
for (int k = 0; k < item.damage.Length; k++)
{
if (item.damage[k] > 0)
{
item.damage[k] = NumbersM.CeilParse <long>(
(item.damage[k] * m) +
((damage * l / i) / damage));
}
}
return(item);
}
/// <summary>
/// Return the health status
/// </summary>
/// <param name="result">Health status string</param>
/// <param name="getLiveAprox">Get the name of the living state instead of exact hp</param>
/// <returns>
/// >= 0 Is alive
/// -1 is Down, -2 Fainted, -3 Unconscious, -4 Dead, -5 Vaporized
/// </returns>
internal int HealthStatus(out string result, bool getLiveAprox = false)
{
var mhp = Health();
double percent = ((double)health / mhp) * 100.00;
if (IsDead())
{
result = EUI.brokenhealth;
if (percent <= -100)
{
result += " Vaporized";
return(-5);
}
else if (percent <= -80)
{
result += " Dead";
return(-4);
}
else if (percent <= -60)
{
result += " Unconscious";
return(-3);
}
else if (percent <= -45)
{
result += " Fainted";
return(-2);
}
else
{
result += " Down";
return(-1);
}
}
else
{
if (getLiveAprox)
{
result = GetAproxHealth(mhp);
}
else
{
result = $"{EUI.health} {Utils.Display(health)}/{Utils.Display(mhp)}";
}
}
return(NumbersM.FloorParse <int>(percent / 10));
}
internal int StaminaE(double percentage)
{
if (percentage != 0)
{
int maxSP = Stamina();
if (percentage > 0 && stamina >= maxSP)
{
return(0);
}
else if (percentage < 0 && stamina <= 0)
{
return(0);
}
return(StaminaE(Math.Max(1, NumbersM.NParse <int>(maxSP * percentage))));
}
return(0);
}
public static string Exploit(Player player, string tool, string item)
{
Tools tools = player.Tools;
int level = player.Area.GetAreaFloorLevel(Program.rng, player.AreaInfo.floor);
(int tier, int tlevel, string name) = tools.CanUse(player, tool);
player.NewEncounter(Encounter.Names.Loot, true);
double mult = Collect(player, item, level, tier * tlevel);
long xp = NumbersM.FloorParse <long>((player.level + level) * mult);
tools.AfterCollect(player, tool, xp);
player.SaveFileMongo();
return($"+{xp} {name} xp");
}
public object[] TakeOnMe(CombatResult owner, CombatResult enemy)
{
if (enemy.abilityUsed.type == Ability.AType.Elemental ||
enemy.abilityUsed.type == Ability.AType.Enchantment ||
enemy.abilityUsed.type == Ability.AType.Martial)
{
if (!enemy.SentHit && RNG(101) <= 15)
{
enemy.sentHit = true;
}
if (enemy.SentHit && RNG(101) <= 10)
{
long healed = owner.character.Healing(NumbersM.CeilParse <long>(owner.character.Health() * 0.10), true);
owner.perkProcs.Add($"{owner.Name} proc'ed {name}'s healing [+{healed} health]");
}
}
return(new object[] { owner, enemy });
}
internal bool ConsumeHealing()
{
int index = inventory.FindIndex(Item.IType.Healing);
if (index > -1)
{
Item meds = inventory.GetItem(index);
long missingHP = Health() - health;
int m = NumbersM.CeilParse <int>(missingHP / (meds.healthBuff + 0f));
int amount = Verify.Max(m, inventory.GetCount(index));
Healing(meds.healthBuff * amount);
StaminaE(meds.staminaBuff * amount);
inventory.Remove(index, amount);
return(true);
}
return(false);
}
public object[] ToxinFilter(CombatResult owner, CombatResult enemy)
{
long toxicdmg = 0;
if (enemy.SentHit && (toxicdmg = enemy.GetTotalDamage(3)) > 0)
{
if (RNG(101) <= 10 + (5 * rank))
{
owner.perkProcs.Add($"Gained " + owner.character.StaminaE(
NumbersM.NParse <int>(toxicdmg * (0.25 + (0.5 * rank)))) +
$" Stamina from Toxin Filter");
rank = 0;
}
else if (rank < maxRank)
{
rank++;
}
}
return(new object[] { owner, enemy });
}
private static EmbedFieldBuilder RestRecover(CharacterMotherClass character, double totalSeconds)
{
long maxHealth = character.Health();
int maxStamina = character.Stamina();
int dex = character.stats.GetDEX();
double hpps = RestorePerSeconds(dex, true);
long hpRestored = Math.Min(maxHealth - character.health,
NumbersM.FloorParse <long>(maxHealth * hpps * totalSeconds));
character.health += hpRestored;
double spps = RestorePerSeconds(dex, false);
int spRestored = Math.Min(maxStamina - character.stamina,
NumbersM.FloorParse <int>(maxStamina * spps * totalSeconds));
character.stamina += spRestored;
return(DUtils.NewField(character.name,
$"Restored {hpRestored} Health and {spRestored} Stamina", true));
}
internal static async Task ViewSchems(Player player, ISocketMessageChannel chan, int displayPage = 1)
{
int count = player.schematics.Count;
if (count == 0)
{
throw NeitsilliaError.ReplyError("No known schematics.");
}
const int itemPerPage = 15;
int pages = NumbersM.CeilParse <int>(count / (double)itemPerPage);
displayPage = Verify.MinMax(displayPage, pages, 1);
int start = (displayPage - 1) * itemPerPage;
string desc = string.Join(Environment.NewLine, player.schematics.GetRange(
start, start + itemPerPage > count ? count - start : itemPerPage));
EmbedBuilder schems = DUtils.BuildEmbed($"{player.name}'s Schematics", desc, $"Page {displayPage}/{pages}", player.userSettings.Color);
await player.NewUI(await chan.SendMessageAsync(embed: schems.Build()), MsgType.Schems, displayPage.ToString());
}
public static void Heal(CombatResult caster, CombatResult target)
{
if (caster.SentHit)
{
Ability heal = caster.abilityUsed;
long mhp = target.character.Health();
if (target.character.HealthStatus(out string status) <= -4)
{
caster.perkProcs.Add($"{heal.name} is not powerful enough to have an effect on {status} targets");
}
else if (target.character.health >= mhp)
{
caster.perkProcs.Add($"Healed {target.Name} for 0HP");
}
else
{
double percHealing = ((heal.level + 10 + caster.character.stats.GetINT()) / 100.00);
long maxOutput = NumbersM.NParse <long>(mhp * percHealing);
long healing = target.character.Healing(maxOutput, true);
caster.perkProcs.Add($"Healed {target.Name} for {healing}HP");
}
}
public static NPC TrainningDummy(int level, int i = 1)
{
var dummy = new NPC(true)
{
profession = ReferenceData.Profession.Creature,
displayName = "Training Dummy " + NumbersM.GetLevelMark(i),
name = "Training Dummy",
xpDropBuff = 0,
desc = "Dummy used for training",
baseLevel = 0,
level = 0,
stats = new Stats()
{
endurance = 100,
intelligence = 0,
strength = 0,
charisma = 0,
dexterity = 0,
perception = 0,
maxhealth = 100 * level,
stamina = 10 * level,
},
abilities = new List <Ability>()
{
LoadAbility.Taunt("Taunt"),
LoadAbility.Brawl("Heal")
}
};
dummy.health = dummy.Health();
dummy.stamina = dummy.Stamina();
return(dummy);
}
public long PowerLevel()
{
long power = Health() + Stamina() + Agility() + NumbersM.NParse <long>(CritChance() +
CritMult());
for (int i = 0; i < ReferenceData.DmgType.Length; i++)
{
power += Damage(i) + Resistance(i);
}
if (stats.intelligence / 2 > 1)
{
power *= stats.intelligence / 2;
}
power += perks.Count * 20;
for (int i = 0; i < 9; i++)
{
var g = equipment.GetGear(i);
if (g != null && g.perk != null)
{
power += 20;
}
}
return(power);
}
internal static int IndexFromRate(int length, double rng) => NumbersM.FloorParse <int>(Math.Pow(length, 0.01 * rng) - 1);
EmbedBuilder DailyReward(Player player)
{
int coinsgain = ReferenceData.dailyCoinsRates + (player.level * 3);
string itemsLoot = null;
string temp = null;
//
StackedItems dailyHealthItem = GetDailyScale(player.level);
if (!player.CollectItem(dailyHealthItem))
{
long kgain = dailyHealthItem.item.baseValue * dailyHealthItem.count;
player.KCoins += (kgain);
temp += "+ " + (kgain) + " Kutsyei coins";
}
else
{
temp = dailyHealthItem.ToString();
}
itemsLoot += temp + Environment.NewLine;
//
StackedItems dailyressource = new StackedItems(Item.RandomItem(player.level,
Program.rng.Next(3)), 1);
if (dailyressource.item.tier < player.level * 1.5)
{
dailyressource.count = Verify.MinMax(NumbersM.CeilParse <int>((player.level / 5.00) - dailyressource.item.tier), 10, 1);
}
if (!player.CollectItem(dailyressource))
{
player.KCoins += dailyressource.item.baseValue * dailyressource.count;
temp = "+ " + (dailyressource.item.baseValue * dailyressource.count) + "Kutsyei coins";
}
else
{
temp = dailyressource.ToString();
}
itemsLoot += temp + Environment.NewLine;
//
itemsLoot += GetDailyGear(player, player.level * 5) + Environment.NewLine;
if (player.level < 9)
{
itemsLoot += GetDailyGear(player, 10, (int)Item.IType.Weapon) + Environment.NewLine;
}
EmbedBuilder loot = new EmbedBuilder();
//
if (Program.dblAPI.connected && false)
{
loot.WithFooter("Vote on DiscordBot List to receive and open Crates for more rewards. " +
Program.dblAPI.WebsiteUrl);
}
player.KCoins += coinsgain;
//
loot.WithTitle("Daily Rations");
player.UserEmbedColor(loot);
loot.AddField("Kutsyei Coins", $"+{coinsgain}~~K~~");
if (itemsLoot == null)
{
itemsLoot = "None";
}
loot.AddField("Items", itemsLoot);
//
player.userTimers.dailyLoot = DateTime.UtcNow.AddDays(1);
player.SaveFileMongo();
//
return(loot);
}
public long XpGain(double xpgain)
{
long xp = NumbersM.NParse <long>(xpgain);
return(XpGain(xp));
}
