public void KilledEnemyGivesFoodOfAllKinds()
{
var env = CreateTestEnv(numEnemies: 100);
env.LootGenerator.Probability = new Roguelike.Probability.Looting();
env.LootGenerator.Probability.SetLootingChance(LootSourceKind.Enemy, LootKind.Food, 1);
var enemies = env.Enemies;
Assert.AreEqual(enemies.Count, 100);
var li = new LootInfo(game, null);
env.KillAllEnemies();
var lootItems = li.GetDiff();
Assert.Greater(lootItems.Count, 0);
var foods = li.Get <Food>().ToList();
Assert.Greater(foods.Count, 40);
var kinds = Enum.GetValues(typeof(FoodKind)).Cast <FoodKind>().Where(i => i != FoodKind.Unset).ToList();
foreach (var kind in kinds)
{
Assert.IsTrue(foods.Any(i => i.Kind == kind));
}
}
//corrutinas comunes
IEnumerator SearchLoot(float time)
{
List <GameObject> members = enemyGroup.GetComponent <GroupManager>().GetMembers();
foreach (GameObject member in members)
{
if (member.GetComponent <Npc>().GetItsLooteable())
{
LootInfo loot = member.GetComponent <Npc>().GetLoot();
if (loot != null)
{
int gold = 0;
gold = Random.Range(loot.minGold, loot.maxGold);
GameObject deckInformation = GameObject.FindGameObjectWithTag("DeckInformation");
deckInformation.GetComponent <DeckInformation>().AddGold(gold);
if (loot.cardsForRetrieve.Length > 0)
{
CardInfo cardInfoFromLoot;
cardInfoFromLoot = loot.cardsForRetrieve[Random.Range(1, loot.cardsForRetrieve.Length)];
deckInformation.GetComponent <DeckInformation>().AddCardToInventory(cardInfoFromLoot);
deck.GetComponent <Deck>().PutCardInDeck(cardInfoFromLoot);
Debug.Log("se adhirio: " + cardInfoFromLoot.description);
}
}
}
}
yield return(new WaitForSeconds(time));
StartCoroutine("FleeOption", 3);
}
public void LotsOfPotionsTest()
{
var des = EquipmentKind.Weapon.ToDescription();
var env = CreateTestEnv();
//GenerationInfo.DebugInfo.EachEnemyGivesPotion = true;
try
{
var lootInfo = new LootInfo(game, null);
ILootSource lootSrc = ActivePlainEnemies.First();//env.Game.Hero
for (int i = 0; i < 10; i++)
{
var pot = env.LootGenerator.GetRandomLoot(LootKind.Potion, 1);
var added = game.GameManager.AddLootReward(pot, lootSrc, false);
Assert.True(added);
var dist = pot.DistanceFrom(lootSrc.GetPoint());
Assert.Less(dist, 5);
Assert.True(dist < 4 || i > 5);
}
var newLootItems = lootInfo.GetDiff();
Assert.AreEqual(newLootItems.Count, 10);
}
catch (System.Exception)
{
//GenerationInfo.DebugInfo.EachEnemyGivesPotion = false;
}
}
private void AddLoot(LootInfo l)
{
if (LootTracker.IsStandardServer(l.Server))
{
lootList.Add(l);
}
//LogInfo($"Looted {l.Item} from {l.Source} in {l.Zone}");
}
public GameObject Drop()
{
float total = GetWeightTotal();
insertionSort(loot);
float num = UnityEngine.Random.Range(0f, total);
foreach (LootInfo info in loot)
{
if (num <= info.rate)
{
if (info.nightOnly)
{
if (LightingManager.Instance.night)
{
return(info.item);
}
else
{
num -= info.rate;
}
}
else
{
return(info.item);
}
}
else
{
num -= info.rate;
}
}
return(null);
void insertionSort(List <LootInfo> unsortedLoot)
{
int n = unsortedLoot.Count;
for (int i = 1; i < n; ++i)
{
LootInfo key = unsortedLoot[i];
int j = i - 1;
while (j >= 0 && unsortedLoot[j].rate > key.rate)
{
unsortedLoot[j + 1] = unsortedLoot[j];
j = j - 1;
}
unsortedLoot[j + 1] = key;
}
loot.Reverse();
}
}
public void SpawnLoot()
{
foreach (Transform storageSpawnpoint in StorageLootParent.transform)
{
foreach (Transform UntakenDrag in storageSpawnpoint.GetComponent <Storage>().UnreadyItems.transform)
{
Destroy(UntakenDrag.gameObject);
}
}
foreach (Transform UnTakenItem in Untaken.transform)
{
Destroy(UnTakenItem.gameObject);
}
foreach (Transform spawnpoint in FreeLootParent.transform)
{
LootInfo li = spawnpoint.gameObject.GetComponent <LootInfo>();
int RandomizedRarity = CheckRandomizedRarity(Random.Range(0, 1000));
if (RandomizedRarity != 8)
{
int RandomizedItem = Random.Range(0, SpawnPointLists[GetLLSpawnPoint(li)].Rarities[RandomizedRarity].ItemTypes[GetLLType(li)].ItemsList.Count);
GameObject clone = Instantiate(SpawnPointLists[GetLLSpawnPoint(li)].Rarities[RandomizedRarity].ItemTypes[GetLLType(li)].ItemsList[RandomizedItem].itemPickupPrefab.gameObject, spawnpoint.transform.position, Quaternion.identity) as GameObject;
clone.transform.parent = Untaken.transform;
}
}
foreach (Transform storageSpawnpoint in StorageLootParent.transform)
{
foreach (Storage.StorageSpawnPoint storagePoint in storageSpawnpoint.gameObject.GetComponent <Storage>().AllSpawnpoints)
{
Storage ss = storageSpawnpoint.gameObject.GetComponent <Storage>();
int RandomizedRarity = CheckRandomizedRarity(Random.Range(0, 1000));
if (RandomizedRarity != 8)
{
int pointIndex = storageSpawnpoint.gameObject.GetComponent <Storage>().AllSpawnpoints.IndexOf(storagePoint);
int RandomizedItem = Random.Range(0, SpawnPointLists[GetSSSpawnPoint(ss, pointIndex)].Rarities[RandomizedRarity].ItemTypes[GetSSType(ss, pointIndex)].ItemsList.Count);
Debug.Log("Spawned");
GameObject clone = Instantiate(SpawnPointLists[GetSSSpawnPoint(ss, pointIndex)].Rarities[RandomizedRarity].ItemTypes[GetSSType(ss, pointIndex)].ItemsList[RandomizedItem].itemDragDropPrefab, storagePoint.Point.transform.position, Quaternion.identity) as GameObject;
clone.GetComponent <ItemCollisionDetection>().CollidingItem = false;
clone.GetComponent <ItemCollisionDetection>().CharCont = storageSpawnpoint.gameObject;
clone.GetComponent <ItemCollisionDetection>().itemDataBase = ItemDB;
clone.GetComponent <ItemCollisionDetection>().Inv = storageSpawnpoint.GetComponent <Storage>().UnreadyItems;
clone.transform.SetParent(storageSpawnpoint.GetComponent <Storage>().UnreadyItems.transform);
clone.GetComponent <ItemCollisionDetection>().posOffseter = new Vector3(ItemDB.GetComponent <ItemDatabase>().items[clone.GetComponent <ItemCollisionDetection>().itemID].cellSize.x, (-ItemDB.GetComponent <ItemDatabase>().items[clone.GetComponent <ItemCollisionDetection>().itemID].cellSize.y), 0);
clone.transform.position = storagePoint.Point.transform.position + clone.gameObject.GetComponent <ItemCollisionDetection>().posOffseter;
clone.GetComponent <ItemCollisionDetection>().SlotOn = storagePoint.Point.gameObject;
clone.GetComponent <ItemCollisionDetection>().CollidingItem = false;
//
//
//clone.transform.parent = Untaken.transform;
}
}
}
LootSpawned = true;
}
public void SetNpcInfo(NpcInfo _npcInfo)
{
npcInfo = _npcInfo;
graphic.GetComponent <SpriteRenderer>().sprite = npcInfo.graphic;
life = npcInfo.LifeValue;
attack = npcInfo.OffensiveValue;
defence = npcInfo.DefensiveValue;
heal = npcInfo.HealingValue;
npcUI.GetComponent <NpcUI>().SetHealth(_npcInfo.LifeValue, life);
npcUI.GetComponent <NpcUI>().SetActionSpended(actionExpended);
itsLooteable = _npcInfo.itsLooteable;
itsInanimateObject = _npcInfo.inanimateObject;
loot = _npcInfo.loot;
}
public void KilledEnemyGivesPotionFromTimeToTime()
{
for (int i = 0; i < loopCount; i++)
{
var env = CreateTestEnv(numEnemies: 100);
var li = new LootInfo(game, null);
env.KillAllEnemies();
var lootItems = li.GetDiff();
Assert.Greater(lootItems.Count, 10);
var potions = li.Get <Potion>();
Assert.Greater(potions.Count, 2);
Assert.Less(potions.Count, 10);
}
}
private LootInfo KillEnemies(int enemiesCount)
{
var env = CreateTestEnv(numEnemies: enemiesCount);
var enemies = env.Enemies;
Assert.AreEqual(enemies.Count, enemiesCount);
var li = new LootInfo(game, null);
env.KillAllEnemies();
var lootItems = li.GetDiff();
Assert.Greater(lootItems.Count, 0);
return(li);
}
public bool GenerateLootAt(LootInfo info, Vector2Int coords)
{
if (UnityEngine.Random.value < info.LootChance)
{
int numRolls = UnityEngine.Random.Range(info.MinRolls, info.MaxRolls + 1);
for (int i = 0; i < numRolls; ++i)
{
int amount = UnityEngine.Random.Range(info.MinItems, info.MaxItems + 1);
// select Data
// _entityController.CreatePickable(_data, item, coords, amount, false);
}
return(true);
}
return(false);
}
public void LotsOfEqTest()
{
var env = CreateTestEnv();
var lootInfo = new LootInfo(game, null);
for (int i = 0; i < 10; i++)
{
var pot = env.LootGenerator.GetRandomLoot(LootKind.Equipment, 1);
var closeEmp = env.Game.Level.GetClosestEmpty(env.Game.Hero, true, true);
var set = env.Game.Level.SetTile(pot, closeEmp.point);
Assert.True(set);
}
var newLootItems = lootInfo.GetDiff();
Assert.AreEqual(newLootItems.Count, 10);
}
public static void AddMobLoot(uint mob, uint QID, uint sID, int itemID, uint rate)
{
LootInfo info = new LootInfo();
List<LootInfo> table;
info.itemID = itemID;
info.QID = QID;
info.SID = sID;
info.rate = rate;
if (MobQuestItem.ContainsKey(mob))
table = MobQuestItem[mob];
else
{
table = new List<LootInfo>();
MobQuestItem.Add(mob, table);
}
table.Add(info);
}
public void GemsLevel()
{
var env = CreateTestEnv();
try
{
var lootInfo = new LootInfo(game, null);
ILootSource lootSrc = ActivePlainEnemies.First();
for (int i = 0; i < 10; i++)
{
var loot = env.LootGenerator.GetRandomLoot(LootKind.Gem, 1) as Gem;
Assert.AreEqual(loot.EnchanterSize, EnchanterSize.Small);
}
}
catch (System.Exception)
{
//GenerationInfo.DebugInfo.EachEnemyGivesPotion = false;
}
}
int GetLLType(LootInfo ll)
{
if (ll.Type == Item.ItemOfType.Drink)
{
return(1);
}
else if (ll.Type == Item.ItemOfType.CraftingMaterial)
{
return(2);
}
else if (ll.Type == Item.ItemOfType.placeable)
{
return(3);
}
else
{
return(0);
}
}
public static void AddMobLoot(uint mob, uint QID, uint sID, int itemID, uint rate)
{
LootInfo info = new LootInfo();
List <LootInfo> table;
info.itemID = itemID;
info.QID = QID;
info.SID = sID;
info.rate = rate;
if (MobQuestItem.ContainsKey(mob))
{
table = MobQuestItem[mob];
}
else
{
table = new List <LootInfo>();
MobQuestItem.Add(mob, table);
}
table.Add(info);
}
/////////////////////////////////////////////////////////
public void KilledEnemyLevelAffectsEnchanter(LootKind kind, int enemyLevel, EnchanterSize[] expectedSizes)
{
var env = CreateTestEnv(true, 10, 2);
env.LootGenerator.Probability = new Roguelike.Probability.Looting();
env.LootGenerator.Probability.SetLootingChance(LootSourceKind.Enemy, kind, 1);
var enemies = AllEnemies;
Assert.GreaterOrEqual(enemies.Count, 5);
enemies.ForEach(i =>
{
SetEnemyLevel(i, enemyLevel);
});
var li = new LootInfo(game, null);
env.KillAllEnemies();
var res = new List <LootKind>();
var lootItems = li.GetDiff();
int expectedKindsCounter = 0;
{
foreach (var loot in lootItems)
{
var expected = kind == loot.LootKind;
if (expected)
{
var ench = loot as Enchanter;
Assert.True(expectedSizes.Contains(ench.EnchanterSize));
expectedKindsCounter++;
}
res.Add(loot.LootKind);
}
}
Assert.Greater(expectedKindsCounter, 0);
}
int GetLLSpawnPoint(LootInfo ll)
{
if (ll.SpawnPoint == Item.ItemSpawnPoint.Houses)
{
return(1);
}
else if (ll.SpawnPoint == Item.ItemSpawnPoint.DestroyedVehicles)
{
return(2);
}
else if (ll.SpawnPoint == Item.ItemSpawnPoint.Military)
{
return(3);
}
else if (ll.SpawnPoint == Item.ItemSpawnPoint.Industrial)
{
return(4);
}
else
{
return(0);
}
}
public void KilledEnemyAtSamePlace()
{
var env = CreateTestEnv(true, 20);
env.LootGenerator.Probability = new Roguelike.Probability.Looting();
env.LootGenerator.Probability.SetLootingChance(LootSourceKind.Enemy, LootKind.Equipment, 1f);
var enemies = game.GameManager.EnemiesManager.GetEnemies().Where(i => i.PowerKind == EnemyPowerKind.Plain).ToList();
var en = enemies[0];
env.KillEnemy(en);
var loot = env.Game.Level.GetTile(en.point);//loot shall be at enemy point
Assert.NotNull(loot as Loot);
var en1 = enemies[1];
Assert.True(env.Game.Level.SetTile(en1, en.point));
Debug.WriteLine("Killing en1...");
var li = new LootInfo(game, null);
var prevCountLevel = env.Game.Level.Loot.Count;
var prevCount = li.Prev.Count;
var prevCopy = li.Prev.ToList();
env.KillEnemy(en1);
var lootItems = li.GetDiff();
if (lootItems.Count == 0)
{
int k = 0;
k++;
}
Assert.GreaterOrEqual(lootItems.Count, 1);
Assert.True(lootItems[0].DistanceFrom(loot) < 2);
}
// #############################################
// ##### EVENTS
// On start
void Start()
{
// Set application framerate to current screen refresh rate
Application.targetFrameRate = Screen.currentResolution.refreshRate;
// Hide cursor
Cursor.visible = false;
// Init loot information struct
lootInfo = new LootInfo();
ResetLootInfo();
// Save references to post process volume settings
postProcessVolume.profile.TryGet <Vignette>(out postProcessVignette);
postProcessVolume.profile.TryGet <ColorAdjustments>(out postProcessColorAdjustments);
// Update UI
UpdateWorth();
UpdateEquipped();
UpdateHeader(whichPPSettingisSet);
// Set post process settings to default
UpdatePP(PPSettings.Default);
}
