//public override void OnItemPickup(Agent agent, SpawnedItemEntity item)
//{
// if (agent.Character == CharacterObject.PlayerCharacter)
// {
// //if (item.WeaponCopy.PrimaryItem != null && item.WeaponCopy.PrimaryItem.ItemCategory == ItemCategory.)
// //{
// //}
// }
//}
public EquipmentElement GetEquipmentWithModifier(ItemObject item, float targetValueFactor)
{
ItemModifierGroup itemModifierGroup;
ArmorComponent armorComponent = item.ArmorComponent;
if (armorComponent != null)
{
itemModifierGroup = armorComponent.ItemModifierGroup;
}
else
{
itemModifierGroup = null;
}
ItemModifierGroup itemModifierGroup1 = itemModifierGroup ?? Campaign.Current.ItemModifierGroupss.FirstOrDefault <ItemModifierGroup>((ItemModifierGroup x) => x.ItemTypeEnum == item.ItemType);
ItemModifier itemModifierWithTarget = null;
if (itemModifierGroup1 != null)
{
itemModifierWithTarget = itemModifierGroup1.GetItemModifierWithTarget(targetValueFactor);
if (itemModifierWithTarget != null)
{
float single = (itemModifierWithTarget.PriceMultiplier < targetValueFactor ? itemModifierWithTarget.PriceMultiplier / targetValueFactor : targetValueFactor / itemModifierWithTarget.PriceMultiplier);
if ((1f < targetValueFactor ? 1f / targetValueFactor : targetValueFactor) > single)
{
itemModifierWithTarget = null;
}
}
}
return(new EquipmentElement(item, itemModifierWithTarget));
}
public static EquipmentElement GetEquipmentWithModifier(ItemObject item, float prosperityFactor)
{
ItemModifierGroup itemModifierGroup;
ArmorComponent armorComponent = item.ArmorComponent;
if (armorComponent != null)
{
itemModifierGroup = armorComponent.ItemModifierGroup;
}
else
{
itemModifierGroup = null;
}
ItemModifierGroup itemModifierGroup1 = itemModifierGroup ?? Campaign.Current.ItemModifierGroupss.FirstOrDefault <ItemModifierGroup>((ItemModifierGroup x) => x.ItemTypeEnum == item.ItemType);
ItemModifier itemModifierWithTarget = null;
if (itemModifierGroup1 != null)
{
float prosperityVariance = 1f;
if (prosperityFactor < 1f)
{
prosperityVariance = MBRandom.RandomFloatRanged(prosperityFactor, 1f);
}
else
{
prosperityVariance = MBRandom.RandomFloatRanged(1f, prosperityFactor);
}
itemModifierWithTarget = itemModifierGroup1.GetRandomModifierWithTarget(prosperityVariance, 1f);
}
return(new EquipmentElement(item, itemModifierWithTarget));
}
private static IEnumerable <ItemRosterElement> LootCasualties(ICollection <TroopRosterElement> shareFromCasualties, float lootFactor, bool playerWin = false)
{
EquipmentElement equipmentElement;
ItemModifier randomModifierWithTarget;
ItemModifier itemModifier;
ItemRoster itemRosters = new ItemRoster();
List <EquipmentElement> equipmentElements = new List <EquipmentElement>();
foreach (TroopRosterElement shareFromCasualty in shareFromCasualties)
{
//for (int i = 0; i < 1; i++)
{
Equipment randomEquipment = GetRandomEquipment(shareFromCasualty.Character);
equipmentElements.Clear();
int num = MBRandom.RoundRandomized(lootFactor);
float lootSkill = lootFactor / .25f;
for (int j = 0; j < num; j++)
{
float expectedLootedItemValue = 30f;
if (playerWin)
{
float valLevel = (float)Math.Max(CharacterObject.PlayerCharacter.Level, shareFromCasualty.Character.Level);
expectedLootedItemValue = 0.8f * ((30f * lootFactor) + (float)(valLevel * valLevel));
}
else
{
expectedLootedItemValue = ItemHelper.GetExpectedLootedItemValue(shareFromCasualty.Character);
}
List <EquipmentElement> randomItems = GetRandomItems(randomEquipment, expectedLootedItemValue);
foreach (EquipmentElement randomItem in randomItems)
{
if (randomItem.Item != null && !randomItem.Item.NotMerchandise && equipmentElements.Count <EquipmentElement>((EquipmentElement x) => x.Item.Type == randomItem.Item.Type) == 0)
{
equipmentElements.Add(randomItem);
}
}
}
for (int k = 0; k < equipmentElements.Count; k++)
{
EquipmentElement item = equipmentElements[k];
ItemRosterElement itemRosterElement = new ItemRosterElement(item.Item, 1, null);
float single = 30f; // ItemHelper.GetExpectedLootedItemValue(shareFromCasualty.Character);
if (playerWin)
{
float valLevel = (float)Math.Max(CharacterObject.PlayerCharacter.Level, shareFromCasualty.Character.Level);
single = 0.8f * (30f * lootFactor) + (float)(valLevel * valLevel);
}
else
{
single = ItemHelper.GetExpectedLootedItemValue(shareFromCasualty.Character);
}
EquipmentElement equipmentElement1 = itemRosterElement.EquipmentElement;
if (!equipmentElement1.Item.HasHorseComponent)
{
equipmentElement1 = itemRosterElement.EquipmentElement;
if (equipmentElement1.Item.HasArmorComponent)
{
equipmentElement1 = itemRosterElement.EquipmentElement;
equipmentElement = itemRosterElement.EquipmentElement;
ItemModifierGroup itemModifierGroup = equipmentElement.Item.ArmorComponent.ItemModifierGroup;
if (itemModifierGroup != null)
{
equipmentElement = itemRosterElement.EquipmentElement;
randomModifierWithTarget = itemModifierGroup.GetRandomModifierWithTarget(single / (float)equipmentElement.GetBaseValue(), 1f);
}
else
{
randomModifierWithTarget = null;
}
equipmentElement1.SetModifier(randomModifierWithTarget);
}
}
else
{
equipmentElement1 = itemRosterElement.EquipmentElement;
equipmentElement = itemRosterElement.EquipmentElement;
ItemModifierGroup itemModifierGroup1 = equipmentElement.Item.HorseComponent.ItemModifierGroup;
if (itemModifierGroup1 != null)
{
equipmentElement = itemRosterElement.EquipmentElement;
itemModifier = itemModifierGroup1.GetRandomModifierWithTarget(single / (float)equipmentElement.GetBaseValue(), 1f);
}
else
{
itemModifier = null;
}
equipmentElement1.SetModifier(itemModifier);
}
itemRosters.Add(itemRosterElement);
}
}
}
return(itemRosters);
}
public static ItemObject GenerateTournamentPrize(TournamentGame tournamentGame, TournamentPrizePool currentPool = null, bool keepTownPrize = true)
{
var numItemsToGet = TournamentXPSettings.Instance.NumberOfPrizeOptions;
bool bRegenAllPrizes = false;
if (currentPool == null)
{
bRegenAllPrizes = true;
currentPool = GetTournamentPrizePool(tournamentGame.Town.Settlement);
}
var allitems = GetItemStringsRevised(tournamentGame, TournamentPrizePoolBehavior.GetActivePrizeTypes());
//Add any existing items if we are filling in missing ones from an already generated pool
var pickeditems = new List <string>();
if (keepTownPrize && !string.IsNullOrWhiteSpace((tournamentGame.Prize.StringId)))
{
pickeditems.Add(tournamentGame.Prize.StringId);
currentPool.SelectedPrizeStringId = tournamentGame.Prize.StringId;
}
try
{
if (!bRegenAllPrizes)
{
foreach (ItemRosterElement existingPrize in currentPool.Prizes)
{
if (!pickeditems.Contains(existingPrize.EquipmentElement.Item.StringId))
{
pickeditems.Add(existingPrize.EquipmentElement.Item.StringId);
}
if (allitems.Contains(existingPrize.EquipmentElement.Item.StringId))
{
allitems.Remove(existingPrize.EquipmentElement.Item.StringId);
}
}
}
}
catch (Exception ex)
{
ErrorLog.Log("ERROR: GetTournamentPrize existingprizes\n" + ex.ToStringFull());
}
//If the totoal pool of unique items is less than our desired number, reduce our pool size.
if (allitems.Count() < numItemsToGet)
{
numItemsToGet = allitems.Count();
}
while (pickeditems.Count < numItemsToGet && allitems.Count() > 0)
{
var randomId = allitems.GetRandomElement <string>();
if (!pickeditems.Contains(randomId))
{
pickeditems.Add(randomId);
allitems.Remove(randomId);
}
}
currentPool.Prizes = new ItemRoster();
foreach (var id in pickeditems)
{
ItemModifier itemModifier = null;
var pickedPrize = Game.Current.ObjectManager.GetObject <ItemObject>(id);
if (TournamentXPSettings.Instance.EnableItemModifiersForPrizes)
{
/* BETA12
* if (TournamentXPSettings.Instance.TownProsperityAffectsItemModifiers)
* {
* var ee = GetEquipmentWithModifier(pickedPrize, pickedPrize.Value * GetProsperityModifier(tournamentGame.Town.Settlement));
* itemModifier = ee.ItemModifier;
* }
* else
* {
*/
if (pickedPrize.HasArmorComponent)
{
ItemModifierGroup itemModifierGroup = pickedPrize.ArmorComponent.ItemModifierGroup;
if (itemModifierGroup != null)
{
itemModifier = itemModifierGroup.GetRandomItemModifier(1f);
}
else
{
itemModifier = null;
}
}
/* BETA12
* }
*/
}
currentPool.Prizes.Add(new ItemRosterElement(pickedPrize, 1, itemModifier));
// currentPool.Prizes.Add(new ItemRosterElement(pickedPrize, 1, null)); //Turn off random item mods for now;
}
if (!keepTownPrize)
{
var selected = currentPool.Prizes.GetRandomElement <ItemRosterElement>();
currentPool.SelectedPrizeStringId = selected.EquipmentElement.Item.StringId;
SetTournamentSelectedPrize(tournamentGame, selected.EquipmentElement.Item);
}
return(currentPool.SelectPrizeItemRosterElement.EquipmentElement.Item);
}
public static ItemModifier AverageItemModifier(ItemModifierGroup group)
{
/*
* public sealed class ItemModifier : MBObjectBase
* {
* private int _damage;
* private int _speed;
* private int _missileSpeed;
* private int _armor;
* private short _hitPoints;
* private short _stackCount;
* private float _mountSpeed;
* private float _maneuver;
* private float _chargeDamage;
* private float _mountHitPoints;
* public TextObject Name { get; private set; }
* public float PriceMultiplier { get; private set; }
* ...
* }
*/
if (group == null)
{
return(null);
}
//var result = new ItemModifier { ID = string.Empty };
var result = MBObjectManager.Instance.CreateObject <ItemModifier>(string.Empty);
float sum = 0;
foreach (var probability in group.ItemModifiersWithProbability.Values)
{
sum += probability.Probability;
}
float damage = 0;
float speed = 0;
float missileSpeed = 0;
float armor = 0;
//float rankIndex = 0;
float priceMultiplier = 0;
//float weightMultiplier = 0;
//float oldness = 0;
//float factorOne = 0;
//float factorTwo = 0;
float hitPoints = 0;
float stackCount = 0;
float mountSpeed = 0;
float maneuver = 0;
float chargeDamage = 0;
float mountHitPoints = 0;
var bindingFlag = BindingFlags.NonPublic | BindingFlags.Instance;
foreach (var modifier in group.ItemModifiersWithProbability.Values)
{
if (modifier.ItemModifier == null)
{
continue;
}
damage += modifier.ItemModifier.ModifyDamage(0) * modifier.Probability / sum;
speed += modifier.ItemModifier.ModifySpeed(0) * modifier.Probability / sum;
missileSpeed += modifier.ItemModifier.ModifyMissileSpeed(0) * modifier.Probability / sum;
armor += modifier.ItemModifier.ModifyArmor(0) * modifier.Probability / sum;
//rankIndex += modifier.ItemModifier.RankIndex * modifier.Probability / sum;
priceMultiplier += modifier.ItemModifier.PriceMultiplier * modifier.Probability / sum;
//weightMultiplier += modifier.ItemModifier.WeightMultiplier * modifier.Probability / sum;
//oldness += modifier.ItemModifier.Oldness * modifier.Probability / sum;
//factorOne += modifier.ItemModifier.FactorOne * modifier.Probability / sum;
//factorTwo += modifier.ItemModifier.FactorTwo * modifier.Probability / sum;
hitPoints += modifier.ItemModifier.ModifyHitPoints(0) * modifier.Probability / sum;
stackCount += modifier.ItemModifier.ModifyStackCount(0) * modifier.Probability / sum;
mountSpeed += modifier.ItemModifier.ModifyMountSpeed(0) * modifier.Probability / sum;
maneuver += modifier.ItemModifier.ModifyMountManeuver(0) * modifier.Probability / sum;
chargeDamage += modifier.ItemModifier.ModifyMountCharge(0) * modifier.Probability / sum;
mountHitPoints += modifier.ItemModifier.ModifyMountHitPoints(0) * modifier.Probability / sum;
}
typeof(ItemModifier).GetField("_damage", bindingFlag)?.SetValue(result, (int)damage);
typeof(ItemModifier).GetField("_speed", bindingFlag)?.SetValue(result, (int)speed);
typeof(ItemModifier).GetField("_missileSpeed", bindingFlag)?.SetValue(result, (int)missileSpeed);
typeof(ItemModifier).GetField("_armor", bindingFlag)?.SetValue(result, (int)armor);
//typeof(ItemModifier).GetField("RankIndex", bindingFlag)?.SetValue(result, (int)rankIndex);
typeof(ItemModifier).GetField("PriceMultiplier", bindingFlag)?.SetValue(result, priceMultiplier);
//typeof(ItemModifier).GetField("WeightMultiplier", bindingFlag)?.SetValue(result, weightMultiplier);
//typeof(ItemModifier).GetField("Oldness", bindingFlag)?.SetValue(result, oldness);
//typeof(ItemModifier).GetField("FactorOne", bindingFlag)?.SetValue(result, (uint)factorOne);
//typeof(ItemModifier).GetField("FactorTwo", bindingFlag)?.SetValue(result, (uint)factorTwo);
typeof(ItemModifier).GetField("_hitPoints", bindingFlag)?.SetValue(result, (short)hitPoints);
typeof(ItemModifier).GetField("_stackCount", bindingFlag)?.SetValue(result, (short)stackCount);
typeof(ItemModifier).GetField("_mountSpeed", bindingFlag)?.SetValue(result, (int)mountSpeed);
typeof(ItemModifier).GetField("_maneuver", bindingFlag)?.SetValue(result, (int)maneuver);
typeof(ItemModifier).GetField("_chargeDamage", bindingFlag)?.SetValue(result, (int)chargeDamage);
typeof(ItemModifier).GetField("_mountHitPoints", bindingFlag)?.SetValue(result, (int)mountHitPoints);
return(result);
}
private IEnumerable <ItemRosterElement> LootCasualties(ICollection <TroopRosterElement> shareFromCasualties, float lootFactor)
{
EquipmentElement equipmentElement;
ItemModifier randomModifierWithTarget;
ItemModifier itemModifier;
ItemRoster itemRosters = new ItemRoster();
List <EquipmentElement> equipmentElements = new List <EquipmentElement>();
foreach (TroopRosterElement shareFromCasualty in shareFromCasualties)
{
for (int i = 0; i < 1; i++)
{
Equipment randomEquipment = LootCollector.GetRandomEquipment(shareFromCasualty.Character);
equipmentElements.Clear();
int num = MBRandom.RoundRandomized(lootFactor);
for (int j = 0; j < num; j++)
{
float expectedLootedItemValue = ItemHelper.GetExpectedLootedItemValue(shareFromCasualty.Character);
EquipmentElement randomItem = randomEquipment.GetRandomItem(expectedLootedItemValue);
if (randomItem.Item != null && !randomItem.Item.NotMerchandise && equipmentElements.Count <EquipmentElement>((EquipmentElement x) => x.Item.Type == randomItem.Item.Type) == 0)
{
equipmentElements.Add(randomItem);
}
}
for (int k = 0; k < equipmentElements.Count; k++)
{
EquipmentElement item = equipmentElements[k];
ItemRosterElement itemRosterElement = new ItemRosterElement(item.Item, 1, null);
float single = ItemHelper.GetExpectedLootedItemValue(shareFromCasualty.Character);
EquipmentElement equipmentElement1 = itemRosterElement.EquipmentElement;
if (!equipmentElement1.Item.HasHorseComponent)
{
equipmentElement1 = itemRosterElement.EquipmentElement;
if (equipmentElement1.Item.HasArmorComponent)
{
equipmentElement1 = itemRosterElement.EquipmentElement;
equipmentElement = itemRosterElement.EquipmentElement;
ItemModifierGroup itemModifierGroup = equipmentElement.Item.ArmorComponent.ItemModifierGroup;
if (itemModifierGroup != null)
{
equipmentElement = itemRosterElement.EquipmentElement;
randomModifierWithTarget = itemModifierGroup.GetRandomModifierWithTarget(single / (float)equipmentElement.GetBaseValue(), 1f);
}
else
{
randomModifierWithTarget = null;
}
equipmentElement1.SetModifier(randomModifierWithTarget);
}
}
else
{
equipmentElement1 = itemRosterElement.EquipmentElement;
equipmentElement = itemRosterElement.EquipmentElement;
ItemModifierGroup itemModifierGroup1 = equipmentElement.Item.HorseComponent.ItemModifierGroup;
if (itemModifierGroup1 != null)
{
equipmentElement = itemRosterElement.EquipmentElement;
itemModifier = itemModifierGroup1.GetRandomModifierWithTarget(single / (float)equipmentElement.GetBaseValue(), 1f);
}
else
{
itemModifier = null;
}
equipmentElement1.SetModifier(itemModifier);
}
itemRosters.Add(itemRosterElement);
}
}
}
return(itemRosters);
}
