public static int AdjustDroppedKamas(IFightResult looter, int teamPP, long baseKamas)
{
int prospecting = looter.Prospecting;
double num = (looter.Fight.GetFightBonus() <= 0) ? 1.0 : (1.0 + (double)looter.Fight.GetFightBonus() / 100.0);
int kamas = (int)((double)baseKamas * ((double)prospecting / (double)teamPP) * num * (double)Rates.KamasRate);
return(FightFormulas.InvokeWinKamasModifier(looter, kamas));
}
public uint AdjustDroppedKamas(IFightResult looter, int teamPP, long baseKamas, int dropBonusPercent)
{
int prospecting = looter.Prospecting;
double num = (looter.Fight.AgeBonus <= 0) ? 1.0 : (1.0 + (double)looter.Fight.AgeBonus / 100.0);
int kamas = (int)((double)baseKamas * ((double)prospecting / (double)teamPP) * num * (double)WorldConfiguration.Instance.KamasRate);
kamas += kamas.GetPercentageOf(dropBonusPercent);
return((uint)kamas);
}
public double AdjustDropChance(IFightResult looter, MonsterDrop item, sbyte dropperGradeId, int monsterAgeBonus, int dropBonusPercent)
{
dropBonusPercent = dropBonusPercent == 0 ? 1 : dropBonusPercent;
var dropRate = item.GetDropRate((int)dropperGradeId);
var prospecting = ((double)looter.Prospecting / 100.0);
int result = (int)(dropRate * (double)prospecting * ((double)monsterAgeBonus / (double)100.0 + (double)1.0) * (double)WorldConfiguration.Instance.DropsRate);
result += result.GetPercentageOf(dropBonusPercent);
return(result / 5d);
}
public static double AdjustDropChance(IFightResult looter, DroppableItem item, Monster dropper, int monsterAgeBonus)
{
var challengeBonus = looter.Fight.GetChallengesBonus();
var idolsBonus = looter.Fight.GetIdolsDropBonus();
var looterPP = looter.Prospecting + ((looter.Prospecting * (challengeBonus + idolsBonus)) / 100d);
var rate = item.GetDropRate((int)dropper.Grade.GradeId) * (looterPP / 100d) * ((monsterAgeBonus / 100d) + 1) * Rates.DropsRate;
return(InvokeDropRateModifier(looter, item, rate));
}
protected override System.Collections.Generic.IEnumerable <IFightResult> GenerateResults()
{
System.Collections.Generic.List <IFightResult> list = new System.Collections.Generic.List <IFightResult>();
list.AddRange(
from entry in base.GetFightersAndLeavers()
where !(entry is SummonedFighter)
select entry.GetFightResult());
if (base.Map.TaxCollector != null && base.Map.TaxCollector.CanGatherLoots())
{
list.Add(new TaxCollectorFightResult(base.Map.TaxCollector, this));
}
FightTeam[] teams = this.m_teams;
for (int i = 0; i < teams.Length; i++)
{
FightTeam team = teams[i];
System.Collections.Generic.IEnumerable <FightActor> enumerable = ((team == base.RedTeam) ? base.BlueTeam : base.RedTeam).GetAllFighters((FightActor entry) => entry.IsDead()).ToList <FightActor>();
IOrderedEnumerable <IFightResult> orderedEnumerable =
from x in list
where x.CanLoot(team)
select x into entry
orderby(entry is TaxCollectorFightResult) ? -1 : entry.Prospecting descending
select entry;
int teamPP = team.GetAllFighters().Sum((FightActor entry) => entry.Stats[PlayerFields.Prospecting].Total);
int challengeSum = base.m_challenges.Sum((entry => entry.GetChallengeBonus()));
long baseKamas = enumerable.Sum((FightActor entry) => (long)((ulong)entry.GetDroppedKamas()));
using (System.Collections.Generic.IEnumerator <IFightResult> enumerator = orderedEnumerable.GetEnumerator())
{
while (enumerator.MoveNext())
{
IFightResult looter = enumerator.Current;
looter.Loot.Kamas = FightFormulas.AdjustDroppedKamas(looter, teamPP, baseKamas);
System.Collections.Generic.IEnumerable <FightActor> arg_1F0_0 = enumerable;
Func <FightActor, System.Collections.Generic.IEnumerable <DroppedItem> > selector = (FightActor dropper) => dropper.RollLoot(looter, challengeSum);
foreach (DroppedItem current in arg_1F0_0.SelectMany(selector))
{
looter.Loot.AddItem(current);
}
if (looter is IExperienceResult)
{
(looter as IExperienceResult).AddEarnedExperience(FightFormulas.CalculateWinExp(looter, team.GetAllFighters(), enumerable));
}
}
}
}
return(list);
}
public static int AdjustDroppedKamas(IFightResult looter, int teamPP, long baseKamas, bool kamasRate = true)
{
var challengeBonus = looter.Fight.GetChallengesBonus();
var idolsBonus = looter.Fight.GetIdolsDropBonus();
var looterPP = looter.Prospecting + ((looter.Prospecting * (challengeBonus + idolsBonus)) / 100d);
var multiplicator = looter.Fight.AgeBonus <= 0 ? 1 : 1 + (looter.Fight.AgeBonus / 5) / 100d;
var kamas = (int)(baseKamas * (looterPP / teamPP) * multiplicator * (kamasRate ? Rates.KamasRate : 1));
return(InvokeWinKamasModifier(looter, kamas));
}
public static int CalculateWinExp(IFightResult fighter, IEnumerable <FightActor> alliesResults, IEnumerable <FightActor> droppersResults)
{
var droppers = droppersResults as MonsterFighter[] ?? droppersResults.ToArray();
var allies = alliesResults as FightActor[] ?? alliesResults.ToArray();
if (!droppers.Any() || !allies.Any())
{
return(0);
}
var sumPlayersLevel = allies.Sum(entry => entry.Level);
var maxPlayerLevel = allies.Max(entry => entry.Level);
var sumMonstersLevel = droppers.Sum(entry => entry.Level);
var sumMonstersHiddenLevel = droppers.OfType <MonsterFighter>().Sum(entry => entry.HiddenLevel == 0 ? entry.Level : entry.HiddenLevel);
var maxMonsterLevel = droppers.Max(entry => entry.Level);
var sumMonsterXp = droppers.Sum(entry => entry.GetGivenExperience());
double levelCoeff = 1;
if (sumPlayersLevel - 5 > sumMonstersLevel)
{
levelCoeff = (double)sumMonstersLevel / sumPlayersLevel;
}
else if (sumPlayersLevel + 10 < sumMonstersLevel)
{
levelCoeff = (sumPlayersLevel + 10) / (double)sumMonstersLevel;
}
var xpRatio = Math.Min(fighter.Level, Math.Truncate(2.5d * maxMonsterLevel)) / sumPlayersLevel * 100d;
var regularGroupRatio = allies.Where(entry => entry.Level >= maxPlayerLevel / 3).Sum(entry => 1);
if (regularGroupRatio <= 0)
{
regularGroupRatio = 1;
}
var baseXp = Math.Truncate(xpRatio / 100 * Math.Truncate(sumMonsterXp * GroupCoefficients[regularGroupRatio - 1] * levelCoeff));
var multiplicator = fighter.Fight.AgeBonus <= 0 ? 1 : 1 + fighter.Fight.AgeBonus / 100d;
var challengeBonus = fighter.Fight.GetChallengesBonus();
var idolsBonus = fighter.Fight.GetIdolsXPBonus();
var idolsMalus = Math.Pow(Math.Min(4, ((double)sumMonstersHiddenLevel / droppers.Count() / maxPlayerLevel)), 2);
var idolsWisdomBonus = Math.Truncate((100 + fighter.Level * 2.5d) * Math.Truncate(idolsBonus * idolsMalus) / 100d);
var xp = (int)Math.Truncate(Math.Truncate(baseXp * (100 + Math.Max(fighter.Wisdom + idolsWisdomBonus, 0)) / 100d) * multiplicator * Rates.XpRate);
xp += (int)Math.Truncate(xp * (challengeBonus / 100d));
return(InvokeWinXpModifier(fighter, xp));
}
protected override IEnumerable <IFightResult> GenerateResults()
{
System.Collections.Generic.List <IFightResult> list = new System.Collections.Generic.List <IFightResult>();
list.AddRange(
from entry in base.GetAllFightersWithLeavers()
where !(entry is IOwnable)
select entry.GetFightResult());
FightTeam[] teams = new FightTeam[] { BlueTeam, RedTeam };
for (int i = 0; i < teams.Length; i++)
{
int xpBonusPercent = 0;
int dropBonusPercent = 0;
if (teams[i] == GetTeamChallenged())
{
xpBonusPercent += GetChallengesExpPercentBonus();
dropBonusPercent += GetChallengesDropPercentBonus();
}
FightTeam team = teams[i];
System.Collections.Generic.IEnumerable <Fighter> enumerable = ((team == base.RedTeam) ? base.BlueTeam : base.RedTeam).GetDeads();
IOrderedEnumerable <IFightResult> orderedEnumerable = list.FindAll(x => x.CanLoot(team)).OrderBy(x => x.Prospecting);
int teamPP = team.GetFighters(false).Sum((Fighter entry) => entry.Stats.Prospecting.TotalInContext());
teamPP += teamPP.GetPercentageOf(dropBonusPercent);
long baseKamas = enumerable.Sum((Fighter entry) => (long)((ulong)entry.GetDroppedKamas()));
using (System.Collections.Generic.IEnumerator <IFightResult> enumerator = orderedEnumerable.GetEnumerator())
{
while (enumerator.MoveNext())
{
IFightResult looter = enumerator.Current;
looter.Loot.Kamas = FormulasProvider.Instance.AdjustDroppedKamas(looter, teamPP, baseKamas, dropBonusPercent);
System.Collections.Generic.IEnumerable <Fighter> arg_1F0_0 = enumerable;
Func <Fighter, System.Collections.Generic.IEnumerable <DroppedItem> > selector = (Fighter dropper) => dropper.RollLoot(looter, dropBonusPercent);
foreach (DroppedItem current in arg_1F0_0.SelectMany(selector))
{
looter.Loot.AddItem(current);
}
if (looter is FightPlayerResult && looter.Outcome == FightOutcomeEnum.RESULT_VICTORY)
{
(looter as FightPlayerResult).AddEarnedExperience(xpBonusPercent);
}
}
}
}
return(list);
}
public static int CalculateWinExp(IFightResult fighter, System.Collections.Generic.IEnumerable <FightActor> alliesResults, System.Collections.Generic.IEnumerable <FightActor> droppersResults)
{
MonsterFighter[] monsters = droppersResults as MonsterFighter[];
FightActor[] droppers = (monsters != null) ? ((FightActor[])monsters) : droppersResults.ToArray <FightActor>();
FightActor[] allies = (alliesResults as FightActor[]) ?? alliesResults.ToArray <FightActor>();
int result;
if (!droppers.Any <FightActor>() || !allies.Any <FightActor>())
{
result = 0;
}
else
{
int sumPlayersLevel = allies.Sum((FightActor entry) => (int)entry.Level);
short maxPlayerLevel = allies.Max((FightActor entry) => entry.Level);
int sumDroppersLevel = droppers.Sum((FightActor entry) => (int)entry.Level);
short maxDropperLevel = droppers.Max((FightActor entry) => entry.Level);
int sumGivenExperience = droppers.Sum((FightActor entry) => entry.GetGivenExperience());
double num4 = 1.0;
if (sumPlayersLevel - 5 > sumDroppersLevel)
{
num4 = (double)sumDroppersLevel / (double)sumPlayersLevel;
}
else
{
if (sumPlayersLevel + 10 < sumDroppersLevel)
{
num4 = (double)(sumPlayersLevel + 10) / (double)sumDroppersLevel;
}
}
double num5 = System.Math.Min((double)fighter.Level, System.Math.Truncate(2.5 * (double)maxDropperLevel)) / (double)sumPlayersLevel * 100.0;
int num6 = (
from entry in allies
where entry.Level >= maxPlayerLevel / 3
select entry).Sum((FightActor entry) => 1);
if (num6 <= 0)
{
num6 = 1;
}
double num7 = System.Math.Truncate(num5 / 100.0 * System.Math.Truncate((double)sumGivenExperience * FightFormulas.GroupCoefficients[num6 - 1] * num4));
double num8 = (fighter.Fight.GetFightBonus() <= 0) ? 1.0 : (1.0 + (double)fighter.Fight.GetFightBonus() / 100.0);
int xp = (int)System.Math.Truncate(System.Math.Truncate(num7 * (double)(100 + fighter.Wisdom) / 100.0) * num8 * (double)Rates.XpRate);
result = FightFormulas.InvokeWinXpModifier(fighter, xp);
}
return(result);
}
public override IEnumerable <DroppedItem> RollLoot(IFightResult looter, int dropBonusPercent)
{
IEnumerable <DroppedItem> result;
if (Alive)
{
result = new DroppedItem[0];
}
else
{
AsyncRandom asyncRandom = new AsyncRandom();
List <DroppedItem> list = new List <DroppedItem>();
int prospectingSum = base.OposedTeam().GetFighters <CharacterFighter>().Sum((CharacterFighter entry) => entry.Stats.Prospecting.TotalInContext());
foreach (var current in
from droppableItem in base.Template.Drops
where prospectingSum >= droppableItem.ProspectingLock && !droppableItem.HasCriteria
select droppableItem)
{
int num = 0;
while (num < current.Count && (current.DropLimit <= 0 || !this.m_dropsCount.ContainsKey(current) || this.m_dropsCount[current] < current.DropLimit))
{
var deci = asyncRandom.NextDouble();
double num2 = (double)asyncRandom.Next(0, 100) + deci;
double num3 = FormulasProvider.Instance.AdjustDropChance(looter, current, GradeId, (int)base.Fight.AgeBonus, dropBonusPercent);
if (num3 >= num2)
{
list.Add(new DroppedItem(current.ItemId, 1u));
if (!this.m_dropsCount.ContainsKey(current))
{
this.m_dropsCount.Add(current, 1);
}
else
{
System.Collections.Generic.Dictionary <MonsterDrop, int> dropsCount;
MonsterDrop key;
(dropsCount = this.m_dropsCount)[key = current] = dropsCount[key] + 1;
}
}
num++;
}
}
result = list;
}
return(result);
}
protected override System.Collections.Generic.IEnumerable <IFightResult> GenerateResults()
{
IFightResult[] array = (
from entry in base.GetFightersAndLeavers()
where !(entry is SummonedFighter)
select entry into fighter
select fighter.GetFightResult()).ToArray <IFightResult>();
IFightResult[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
IFightResult fightResult = array2[i];
FightPlayerResult fightPlayerResult = fightResult as FightPlayerResult;
if (fightPlayerResult != null)
{
fightPlayerResult.SetEarnedHonor(this.CalculateEarnedHonor(fightPlayerResult.Fighter), this.CalculateEarnedDishonor(fightPlayerResult.Fighter));
}
}
return(array);
}
public static int InvokeWinKamasModifier(IFightResult looter, int kamas)
{
var handler = WinKamasModifier;
return(handler != null?handler(looter, kamas) : kamas);
}
public static double InvokeDropRateModifier(IFightResult looter, DroppableItem item, double rate)
{
var handler = DropRateModifier;
return(handler != null?handler(looter, item, rate) : rate);
}
public override System.Collections.Generic.IEnumerable <DroppedItem> RollLoot(IFightResult looter, int challengeBonus)
{
System.Collections.Generic.IEnumerable <DroppedItem> result;
if (!base.IsDead())
{
result = new DroppedItem[0];
}
else
{
AsyncRandom asyncRandom = new AsyncRandom();
System.Collections.Generic.List <DroppedItem> list = new System.Collections.Generic.List <DroppedItem>();
int prospectingSum = base.OpposedTeam.GetAllFighters <CharacterFighter>().Sum((CharacterFighter entry) => entry.Stats[PlayerFields.Prospecting].Total);
foreach (DroppableItem current in
from droppableItem in this.Monster.Template.DroppableItems
where prospectingSum >= droppableItem.ProspectingLock
select droppableItem)
{
int num = 0;
while (num < current.RollsCounter && (current.DropLimit <= 0 || !this.m_dropsCount.ContainsKey(current) || this.m_dropsCount[current] < current.DropLimit))
{
double num2 = (double)asyncRandom.Next(0, 100) + asyncRandom.NextDouble();
double num3 = FightFormulas.AdjustDropChance(looter, current, this.Monster, this.Fight.GetFightBonus());
if (num3 >= num2)
{
list.Add(new DroppedItem((int)current.ItemId, 1u));
if (!this.m_dropsCount.ContainsKey(current))
{
this.m_dropsCount.Add(current, 1);
}
else
{
System.Collections.Generic.Dictionary <DroppableItem, int> dropsCount;
DroppableItem key;
(dropsCount = this.m_dropsCount)[key = current] = dropsCount[key] + 1;
}
}
num++;
}
}
result = list;
}
return(result);
}
public static int InvokeWinXpModifier(IFightResult looter, int xp)
{
var handler = WinXpModifier;
return(handler != null?handler(looter, xp) : xp);
}
// TODO: Rewrite drops
protected override IEnumerable <IFightResult> GenerateResults()
{
List <IFightResult> allFighters = new List <IFightResult>();
allFighters.AddRange(from entry in this.GetAllFightersWithLeavers()
where !(entry is IOwnable)
select entry.GetFightResult());
FightTeam[] teams = { this.BlueTeam, this.RedTeam };
foreach (FightTeam team in teams)
{
int xpBonusPercent = 0;
int dropBonusPercent = 0;
if (team == this.GetTeamChallenged())
{
xpBonusPercent += this.GetChallengesExpPercentBonus();
dropBonusPercent += this.GetChallengesDropPercentBonus();
}
FightTeam enemyTeam = team == this.RedTeam ? this.BlueTeam : this.RedTeam;
IEnumerable <Fighter> deadEnemies = enemyTeam.GetDeads();
// Retrieve the fighters who can loot, ordered by their pp (asc)
List <IFightResult> looterFighters = allFighters.FindAll(x => x.CanLoot(team));
IOrderedEnumerable <IFightResult> orderedLooters = looterFighters.OrderBy(x => x.Prospecting);
List <Fighter> fighters = team.GetFighters(false);
int teamPP = fighters.Sum(entry => entry.Stats.Prospecting.TotalInContext());
teamPP += teamPP.GetPercentageOf(dropBonusPercent);
// drops
List <DroppedItem> teamLoots = new List <DroppedItem>();
IEnumerable <DroppedItem> Selector(Fighter dropper) => dropper.RollLoot(teamPP, dropBonusPercent);
foreach (DroppedItem current in deadEnemies.SelectMany(Selector))
{
teamLoots.Add(current);
}
long baseKamas = deadEnemies.Sum(entry => (long)((ulong)entry.GetDroppedKamas()));
using (IEnumerator <IFightResult> orderedLootersEnumerator = orderedLooters.GetEnumerator()) {
while (orderedLootersEnumerator.MoveNext())
{
IFightResult looter = orderedLootersEnumerator.Current;
// kamas
looter.Loot.Kamas = FormulasProvider.Instance.AdjustDroppedKamas(looter, teamPP, baseKamas, dropBonusPercent);
// Xp
if (looter is FightPlayerResult && looter.Outcome == FightOutcomeEnum.RESULT_VICTORY)
{
(looter as FightPlayerResult).AddEarnedExperience(xpBonusPercent);
}
}
// Distribution of loots :
if (teamLoots.Any())
{
AsyncRandom rand = new AsyncRandom();
// For each looted item...
foreach (DroppedItem item in teamLoots)
{
// We choose a random looter, but pp still has a little impact on the choice.
// For each player, we generate a random number between 0 and its max prospecting in context
// We sort the list in ascending order and get the last. We therefore get the fighter with the higher randomly generated number.
// Prospecting still has an impact since a player with higher pp has more chances to get a higher random number.
Fighter randomLooter = fighters.OrderBy(x => x.Stats.Prospecting.TotalInContext() * rand.NextDouble()).Last();
// Give the item looted by the team to this player.
randomLooter.Loot.AddItem(item);
}
}
}
}
return(allFighters);
}
protected override IEnumerable <IFightResult> GenerateLeaverResults(CharacterFighter leaver, out IFightResult leaverResult)
{
var rankLoose = CalculateRankLoose(leaver);
leaverResult = null;
var list = new List <IFightResult>();
foreach (var fighter in GetFightersAndLeavers().OfType <CharacterFighter>())
{
var outcome = fighter.Team == leaver.Team
? FightOutcomeEnum.RESULT_LOST
: FightOutcomeEnum.RESULT_VICTORY;
var result = new ArenaFightResult(fighter, outcome, new FightLoot(), fighter == leaver ? rankLoose : 0, false);
if (fighter == leaver)
{
leaverResult = result;
}
list.Add(result);
}
return(list);
}
public override IEnumerable <DroppedItem> RollLoot(IFightResult looter)
{
// have to be dead before
if (!IsDead())
{
return(new DroppedItem[0]);
}
var random = new AsyncRandom();
var items = new List <DroppedItem>();
var prospectingSum = OpposedTeam.GetAllFighters <CharacterFighter>().Sum(entry => entry.Stats[PlayerFields.Prospecting].Total);
var droppedGroups = new List <int>();
foreach (var droppableItem in Monster.Template.DroppableItems.Where(droppableItem => prospectingSum >= droppableItem.ProspectingLock).Shuffle())
{
if (droppedGroups.Contains(droppableItem.DropGroup))
{
continue;
}
if (looter is TaxCollectorProspectingResult && droppableItem.TaxCollectorCannotLoot)
{
continue;
}
for (var i = 0; i < droppableItem.RollsCounter; i++)
{
if (droppableItem.DropLimit > 0 && m_dropsCount.ContainsKey(droppableItem) && m_dropsCount[droppableItem] >= droppableItem.DropLimit)
{
break;
}
var chance = (random.Next(0, 100) + random.NextDouble());
var dropRate = FightFormulas.AdjustDropChance(looter, droppableItem, Monster, Fight.AgeBonus);
if (!(dropRate >= chance))
{
continue;
}
if (droppableItem.DropGroup != 0)
{
droppedGroups.Add(droppableItem.DropGroup);
}
items.Add(new DroppedItem(droppableItem.ItemId, 1));
if (!m_dropsCount.ContainsKey(droppableItem))
{
m_dropsCount.Add(droppableItem, 1);
}
else
{
m_dropsCount[droppableItem]++;
}
}
}
return(items);
}
public static double AdjustDropChance(IFightResult looter, DroppableItem item, Monster dropper, int bonus)
{
double rate = item.GetDropRate((int)dropper.Grade.GradeId) * ((double)looter.Prospecting / 100.0) * ((double)bonus / 100.0 + 1.0) * (double)Rates.DropsRate;
return(FightFormulas.InvokeDropRateModifier(looter, item, rate));
}
public static int InvokeWinXpModifier(IFightResult looter, int xp)
{
Func <IFightResult, int, int> winXpModifier = FightFormulas.WinXpModifier;
return((winXpModifier != null) ? winXpModifier(looter, xp) : xp);
}
public static double InvokeDropRateModifier(IFightResult looter, DroppableItem item, double rate)
{
Func <IFightResult, DroppableItem, double, double> dropRateModifier = FightFormulas.DropRateModifier;
return((dropRateModifier != null) ? dropRateModifier(looter, item, rate) : rate);
}
public static int InvokeWinKamasModifier(IFightResult looter, int kamas)
{
Func <IFightResult, int, int> winKamasModifier = FightFormulas.WinKamasModifier;
return((winKamasModifier != null) ? winKamasModifier(looter, kamas) : kamas);
}
