public override void Open()
{
base.Open();
StorageBuilding sb = (StorageBuilding)obj;
for (int a = 0; a < sb.NumOfTotalTypes; a++)
{
uiObjectDatabase = obj.UIObjects;
//for simple grid
if (sb.Inventory[a] > 0 && simpleInventoryGrid != null)
{
GameObject g1 = Instantiate(uiObjectDatabase.storageItem_smpl);
g1.transform.SetParent(simpleInventoryGrid.transform);
StorageItem_smpl s = g1.GetComponent <StorageItem_smpl>();
s.sb = sb;
s.index = a;
noItems.SetActive(false);
}
//entry in advanced grid
GameObject g2 = Instantiate(uiObjectDatabase.storageItem_adv);
g2.transform.SetParent(advancedInventoryGrid.transform);
StorageItem_adv si = g2.GetComponent <StorageItem_adv>();
si.index = a;
si.sb = sb;
}
}
/// <summary>
/// Constructor for the GameWorld class
/// </summary>
/// <param name="width">The width of the world</param>
/// <param name="height">The height of the world</param>
public GameWorld(int width, int height)
{
instance = this;
gameWidth = width;
gameHeight = height;
// Init the time, graph, grid- and tilessystem
time = new Time();
materialCollection = new MaterialCollector(true);
graph = new Graph();
grid = new GridSystem();
tiles = new TileSystem();
// Initializations for the tiles-, gridsystem and graph
tiles.initTiles();
grid.initGrid();
// A temp NPC to test stuff with
Gatherer npc = new Gatherer(new Vector2D(20, 100), // Position
20, // Bounding Radius
new Vector2D(0, 0), // Velocity
80, // Max Speed
Vector2D.Up, // Heading
1, // Mass
new Vector2D(15, 15), // Scale
0.05f, // Turnrate
10, // Max Force
15, // Carry Capacity
Material.WOOD.id); // MatID
//Gatherer npc2 = new Gatherer(new Vector2D(60, 100), // Position
// 20, // Bounding Radius
// new Vector2D(0, 0), // Velocity
// 80, // Max Speed
// Vector2D.Left, // Heading
// 1, // Mass
// new Vector2D(15, 15), // Scale
// 0.05f, // Turnrate
// 10, // Max Force
// 15, // Carry Capacity
// 2); // MatID
StorageBuilding storage = new StorageBuilding(new Vector2D(400, 200), new Vector2D(40, 40));
graph.initGraph();
tiles.AddResources();
// Setting the path for the npc to follow
//npc.path.Set(Path.GetPathTo(tiles.tiles[TileSystem.GetIndexOfTile(npc.position)], Material.WOOD));
//npc2.path.Set(Path.GetPathTo(tiles.tiles[TileSystem.GetIndexOfTile(npc2.position)], Material.STONE));
// Adding the npc to the world
entities.Add(npc);
//entities.Add(npc2);
storage.SetEntranceEdge();
buildings.Add(storage);
}
private void AdministrateStorage()
{
foreach (Building building in player.Buildings)
{
Console.WriteLine($"Almacenamiento: {building.Name}");
if (building.GetType() == typeof(StorageBuilding))
{
StorageBuilding storageBuilding = building as StorageBuilding;
int n = 1;
foreach (FinishedProduct finishedProduct in storageBuilding.Products)
{
Console.WriteLine($"{n} - {finishedProduct.Name}");
n++;
}
Console.WriteLine($"Seleccione el elemento a vender o 0 para continuar");
int userOption = Int32.Parse(Console.ReadLine());
if (userOption != 0 && userOption < storageBuilding.Products.Count)
{
FinishedProduct selectedProduct = storageBuilding.Products[userOption - 1];
int indexOfProduct = storageBuilding.Products.IndexOf(selectedProduct);
player.Money += selectedProduct.Price * selectedProduct.Quality;
storageBuilding.Products.RemoveAt(indexOfProduct);
}
}
}
}
public bool HasGood(int num, int item, ItemType type)
{
GameObject[] objs = GameObject.FindGameObjectsWithTag("StorageBuilding");
if (objs.Length == 0 && num != 0)
{
return(false);
}
else if (objs.Length == 0)
{
return(true);
}
int sum = 0;
foreach (GameObject go in objs)
{
StorageBuilding strg = go.GetComponent <StorageBuilding>();
//if storage building does not store that type of item, continue
if (strg.typeStored != type)
{
continue;
}
sum += strg.Inventory[item];
}
Debug.Log(sum + " " + num);
return(sum >= num);
}
public override void UpdateOverviewPage()
{
base.UpdateOverviewPage();
StorageBuilding sb = (StorageBuilding)obj;
storageLabel.text = sb.TotalAmountStored() + "/" + sb.stockpile + " full";
storageBar.fillAmount = (float)sb.TotalAmountStored() / sb.stockpile;
}
public SimplePriorityQueue <StorageBuilding> FindStorageBuildingToAccept(ItemOrder io)
{
int num = io.amount;
int item = io.item;
ItemType type = io.type;
GameObject[] objs = GameObject.FindGameObjectsWithTag("StorageBuilding");
SimplePriorityQueue <StorageBuilding> queue = new SimplePriorityQueue <StorageBuilding>();
if (objs.Length == 0)
{
return(queue);
}
foreach (GameObject go in objs)
{
StorageBuilding strg = go.GetComponent <StorageBuilding>();
//if null, continue
if (strg == null)
{
continue;
}
//only add to list if it stores this type
if (strg.typeStored != type)
{
continue;
}
if (!strg.Operational)
{
continue;
}
//only add to list if it has an entrance
List <Node> entrancesHere = GetAdjRoadTiles();
List <Node> entrancesThere = strg.GetAdjRoadTiles();
if (entrancesHere.Count == 0 || entrancesThere.Count == 0)
{
continue;
}
//only add to list if it can accept amount
if (!strg.CanAcceptAmount(num, item))
{
continue;
}
float distance = entrancesHere[0].DistanceTo(entrancesThere[0]);
queue.Enqueue(strg, distance);
}
return(queue);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
StorageBuilding storageBuilding = await db.StorageBuildings.FindAsync(id);
db.StorageBuildings.Remove(storageBuilding);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public StorageBuildingSave(GameObject go) : base(go)
{
StorageBuilding s = go.GetComponent <StorageBuilding>();
inventory = s.Inventory;
queue = s.Queue;
willAccept = s.WillAccept;
willGet = s.WillGet;
}
public override void Activate()
{
base.Activate();
if (Destination is StorageBuilding)
{
StorageBuilding o = (StorageBuilding)Destination;
o.ExpectItem(Order);
}
}
public async Task <ActionResult> Edit([Bind(Include = "PrimaryKey,MaxStorage,Name,Level,MaxLevel,ImgUrl")] StorageBuilding storageBuilding)
{
if (ModelState.IsValid)
{
db.Entry(storageBuilding).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(storageBuilding));
}
// GET: StorageBuildings/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
StorageBuilding storageBuilding = await db.StorageBuildings.FindAsync(id);
if (storageBuilding == null)
{
return(HttpNotFound());
}
return(View(storageBuilding));
}
public void ExportProduct()
{
if (!ActiveCarryerWalker)
{
StorageBuilding s = FindStorageBuildingToAccept(Product);
if (s == null)
{
return;
}
SpawnGiver(Product, s);
TimeToProduce = timeToProduceMax;
Producing = false;
}
}
public static void PlaceBuildingOnMap(GameObject GO, Building building, Vector2Int tileID)
{
GameObject.Destroy(TileMap[tileID.x, tileID.y].TileGo);
TileMap[tileID.x, tileID.y] = new TileWithBuilding(GO, tileID, building);
if (building is Road)
{
RoadMap[tileID.x, tileID.y] = new Node(true, GO.transform.position, tileID.x, tileID.y);
}
else if (building is StorageBuilding)
{
StorageBuilding st = (StorageBuilding)building;
NewStorageBuildingPlaced.Invoke(st);
StorageBuildings.Add(st);
}
}
public void GetOrRemove()
{
//count through inventory so long as carryerwalker isn't active
for (int a = 0; a < NumOfTotalTypes && !ActiveCarryerWalker; a++)
{
//only keep going if WillGet[a] is true
if (!WillGet[a])
{
continue;
}
//if empty space, find other storage with stuff
if (EmptySpaceFor(a) > 0)
{
ItemOrder io = new ItemOrder(EmptySpaceFor(a), a, typeStored);
//if building is found, send getter
StorageBuilding sb = FindStorageBuildingThatHas(io);
if (sb != null)
{
SpawnGetter(io, sb);
}
}
//else find storage to accept surplus
else
{
int amountToRemove = (int)(Inventory[a] - (storageSpace * WillAccept[a]));
if (amountToRemove == 0)
{
continue;
}
ItemOrder io = new ItemOrder(amountToRemove, a, typeStored);
//if building is found, remove stuff from inventory and send giver
StorageBuilding sb = FindStorageBuildingToAccept(io);
if (sb != null)
{
Inventory[a] -= amountToRemove;
SpawnGiver(io, sb);
UpdateVisibleGoods();
}
}
}
}
public override void OnceAtDestination()
{
//if amount at destination is less than needed, set order.num to that amount
StorageBuilding strg = (StorageBuilding)Destination;
if (Order.amount > strg.Inventory[Order.item])
{
Order.amount = strg.Inventory[Order.item];
}
//subtract what we're taking away from the inventory
strg.RemoveItem(Order);
float totalGain = Order.ExchangeValue();
money.GainFromExports(totalGain, Order.type);
}
public override void OnceAtDestination()
{
base.OnceAtDestination();
//if amount at destination is less than needed, set order.num to that amount
StorageBuilding strg = (StorageBuilding)Destination;
if (Order.amount > strg.Inventory[Order.item])
{
Order.amount = strg.Inventory[Order.item];
}
//subtract what we're taking away from the inventory
strg.Inventory[Order.item] -= Order.amount;
money.Sheqels += (int)Order.ExchangeValue();
}
protected virtual void SendCourierWithProductsFunc()
{
StorageBuilding storageBuildingToUse = FindStorageBuilding();
if (storageBuildingToUse != null)
{
// send courier with products
if (storageBuildingToUse != null)
{
HexTile tileToUse = EntranceTiles[Random.Range(0, EntranceTiles.Count - 1)];
OnMapCouriers.Add(Instantiate(GlobalAttributes.Global.Units[(int)Units.Courier], tileToUse.transform.position, Quaternion.identity, transform));
OnMapCouriers[OnMapCouriers.Count - 1].GetComponent <Courier>().AddToInventory(EmptyStorage());
OnMapCouriers[OnMapCouriers.Count - 1].GetComponent <Courier>().SetOutboundCourier(this, storageBuildingToUse);
CourierCount--;
}
//use on map couriers to track who has been sent.
}
}
public void GetIngredients()
{
for (int a = 0; a < ingredientMax.Length; a++)
{
if (!HaveEnough(a))
{
ItemOrder io = new ItemOrder(IngredientNeeded(a), ingredients[a]);
StorageBuilding sb = FindStorageBuildingThatHas(io);
if (sb != null)
{
SpawnGetter(io, sb);
}
return;
}
}
}
public static IResouceReceiver GetClosestResourceReceiver(ResourceType resource, Vector3 relativeTo)
{
float minDistance = Mathf.Infinity;
StorageBuilding closest = null;
foreach (BaseUnit unit in _unitInScene)
{
if (unit is IResouceReceiver)
{
float currentDistance = Vector3.Distance(unit.transform.position, relativeTo);
if (currentDistance < minDistance && (unit as IResouceReceiver).AcceptResource(resource))
{
closest = unit as StorageBuilding;
minDistance = currentDistance;
}
}
}
return(closest as IResouceReceiver);
}
public override void VisitBuilding(int a, int b)
{
base.VisitBuilding(a, b);
StorageBuilding market = (StorageBuilding)Origin;
House house = world.Map.GetBuildingAt(a, b).GetComponent <House>();
if (house == null)
{
return;
}
int numTypes = market.typeStored == ItemType.Food ? (int)FoodType.END : (int)GoodType.END;
//go through inventory
for (int item = 0; item < numTypes; item++)
{
//if the house does not want any of this item, don't sell
SellItem(house, item, market.typeStored, market.Inventory[item]);
}
}
public void GetOrRemove()
{
//count through inventory so long as carryerwalker isn't active
for (int a = 0; a < NumOfTotalTypes; a++)
{
//only keep going if WillGet[a] is true
if (!WillGet[a])
{
continue;
}
//if empty space, find other storage with stuff
if (EmptySpaceFor(a) > (stockpile * .90f * WillAccept[a]))
{
ItemOrder io = new ItemOrder(EmptySpaceFor(a), a, typeStored);
//if building is found, send getter
SpawnGetterToStorage(io);
}
//else find storage to accept surplus
else if (Inventory[a] > stockpile * WillAccept[a])
{
int amountToRemove = (int)(Inventory[a] - (stockpile * WillAccept[a]));
ItemOrder io = new ItemOrder(amountToRemove, a, typeStored);
//if building is found, remove stuff from inventory and send giver
Carryer cart = SpawnGiverToStorage(io);
if (!ActiveSmartWalker)
{
return;
}
StorageBuilding strg = (StorageBuilding)cart.Destination;
RemoveItem(io);
UpdateVisibleGoods();
}
}
}
void showBuildingInfo()
{
if (GameUtility.GetTileUnderMousePosition(out Tile tile))
{
if (tile is TileWithBuilding tileWithBuilding)
{
if (tileWithBuilding.Building is StorageBuilding)
{
StorageBuilding storageBuilding = (StorageBuilding)tileWithBuilding.Building;
StorageInfo.ShowRecources(storageBuilding.Storage);
}
else if (tileWithBuilding.Building is BuildingNearRoad buildingNearRoad)
{
BuildingInfoUI.ShowUI(buildingNearRoad);
}
}
else
{
//Debug.Log("Тайл " + tile.TileID + " без строения");
}
}
}
public override void OnceAtDestination()
{
base.OnceAtDestination();
//if amount at destination is less than needed, set order.num to that amount
StorageBuilding strg = (StorageBuilding)Destination;
if (Order.amount > strg.Inventory[Order.item])
{
Order.amount = strg.Inventory[Order.item];
}
//subtract what we're taking away from the inventory
strg.Inventory[Order.item] -= Order.amount;
strg.UpdateVisibleGoods();
if (Origin is StorageBuilding)
{
StorageBuilding o = (StorageBuilding)Origin;
o.Queue[Order.item] += Order.amount;
}
}
protected StorageBuilding FindStorageBuilding()
{
// find closest storage building with space
List <BaseBuilding> StorageBuildings = TeamManager.TM.Teams[TeamID].BuildingsList.FindAll(x => x is StorageBuilding);
StorageBuilding storageBuildingToUse = null;
float dist = float.MaxValue;
for (int i = 0; i < StorageBuildings.Count; ++i)
{
float tempDist = Vector3.Distance(transform.position, StorageBuildings[i].transform.position);
if (tempDist < dist)
{
if (((StorageBuilding)StorageBuildings[i]).RemainingSpace > 5)
{
storageBuildingToUse = (StorageBuilding)StorageBuildings[i];
}
}
}
return(storageBuildingToUse);
}
protected override void onNewStorageBuild(StorageBuilding storageBuilding)
{
}
public abstract void OnNewStorageAvaliable(StorageBuilding storageBuilding);
public override void OnNewStorageAvaliable(StorageBuilding storageBuilding)
{
Ab_Output.OnNewStorageAvaliable(storageBuilding.Storage);
}
public override void Open()
{
base.Open();
StorageBuilding sb = (StorageBuilding)obj;
ItemType type = sb.typeStored;
string[] items = new string[0];
int length = 0;
switch (type)
{
case ItemType.Food:
length = (int)FoodType.END;
items = new string[length];
Enums.foodDict.Keys.CopyTo(items, 0);
break;
case ItemType.Good:
length = (int)GoodType.END;
items = new string[length];
Enums.goodDict.Keys.CopyTo(items, 0);
break;
case ItemType.Resource:
length = (int)ResourceType.END;
items = new string[length];
Enums.resourceDict.Keys.CopyTo(items, 0);
break;
}
List <string> sorted = new List <string>(items);
sorted.Sort();
foreach (string item in sorted)
{
if (!ResourcesDatabase.ItemAllowed(item))
{
continue;
}
Node n = Enums.GetItemData(item);
int index = n.x;
////for simple grid
//if (sb.Inventory[index] > 0) {
// GameObject g1 = Instantiate(storageitem_smpl);
// g1.transform.SetParent(simpleInventoryGrid.transform);
// StorageItem_smpl s = g1.GetComponent<StorageItem_smpl>();
// s.sb = sb;
// s.index = index;
// noItems.SetActive(false);
//}
//entry in advanced grid
GameObject g2 = Instantiate(UIObjectDatabase.GetUIElement("StorageItem_adv"));
g2.transform.SetParent(advancedInventoryGrid);
StorageItem_adv si = g2.GetComponent <StorageItem_adv>();
si.index = index;
si.sb = sb;
}
}
public SimplePriorityQueue <StorageBuilding> FindStorageBuildingThatHas(ItemOrder io)
{
int num = io.amount;
int item = io.item;
ItemType type = io.type;
GameObject[] objs = GameObject.FindGameObjectsWithTag("StorageBuilding");
SimplePriorityQueue <StorageBuilding> queue = new SimplePriorityQueue <StorageBuilding>();
if (objs.Length == 0)
{
return(queue);
}
int smallestAmountOfItem = 0;
foreach (GameObject go in objs)
{
StorageBuilding strg = go.GetComponent <StorageBuilding>();
if (this is StorageBuilding)
{
if (strg == (StorageBuilding)this)
{
continue;
}
}
//if storage building does not store that type of item, continue
if (strg.typeStored != type)
{
continue;
}
if (!strg.Operational)
{
continue;
}
//if storage building or this structure have no entrances, continue
List <Node> entrancesHere = GetAdjRoadTiles();
List <Node> entrancesThere = strg.GetAdjRoadTiles();
if (entrancesHere.Count == 0 || entrancesThere.Count == 0)
{
continue;
}
if (strg.Inventory[item] == 0)
{
continue;
}
//if has less than the needed amount of Item and less than other discovered inventories, continue
if (strg.Inventory[item] < num && strg.Inventory[item] < smallestAmountOfItem)
{
continue;
}
smallestAmountOfItem = strg.Inventory[item];
float distance = entrancesHere[0].DistanceTo(entrancesThere[0]);
queue.Enqueue(strg, distance);
}
return(queue);
}
private void NextTurn()
{
Console.WriteLine("Pasando de turno...");
Console.ForegroundColor = ConsoleColor.Red;
// Se actuliza el precio de las semillas en el mercado
foreach (Seed seed in market.Seeds)
{
seed.AddPriceHistory();
}
// Se actulizan los datos de los edificios del usuario
foreach (Building building in player.buildings)
{
if (building.GetType() == typeof(Plantation))
{
// Se actulizan datos de las plantaciones
Plantation plantationBuilding = building as Plantation;
Seed plantationSeed = plantationBuilding.Seed;
plantationBuilding.Maturity += 1;
if (plantationBuilding.Sick == false)
{
plantationBuilding.SickPast = false;
}
if (plantationBuilding.HasUndergrowth == false)
{
plantationBuilding.HasUndergrowthPast = false;
}
if (plantationBuilding.HasWorms == false)
{
plantationBuilding.HasWormsPast = false;
}
plantationBuilding.GetSick();
plantationBuilding.GetUndergrowth();
plantationBuilding.GetWorms();
// Se revisan las proiedades de la plantacion
if (plantationBuilding.Health == 0)
{
Console.WriteLine($"-La salud de la plantacion {plantationBuilding.Name} llego a 0.");
}
if (plantationBuilding.Water == 0)
{
Console.WriteLine($"-El nivel de agua de la plantacion {plantationBuilding.Name} llego a 0.");
}
if (plantationBuilding.Nutrients == 0)
{
Console.WriteLine($"-El nivel de nutrientes de la plantacion {plantationBuilding.Name} llego a 0.");
}
if (plantationBuilding.Nutrients < plantationSeed.MinimumLevelOfNutrients && plantationBuilding.Health != 0)
{
plantationBuilding.Health -= plantationSeed.PenaltyForLackOfNutrients;
Console.WriteLine($"-La salud de la plantacion {plantationBuilding.Name} disminuyo a {plantationBuilding.Health} debido a falta de nutrientes.");
}
if (plantationBuilding.Water < plantationSeed.MinimumWaterLevel && plantationBuilding.Health != 0)
{
plantationBuilding.Health -= plantationSeed.PenaltyForLackOfWater;
Console.WriteLine($"-La salud de la plantacion {plantationBuilding.Name} disminuyo a {plantationBuilding.Health} debido a falta de Agua.");
}
if (plantationBuilding.Water != 0)
{
plantationBuilding.Water -= plantationSeed.WaterConsume;
}
if (plantationBuilding.Nutrients != 0)
{
plantationBuilding.Nutrients -= plantationSeed.NutrientConsumption;
}
if (plantationBuilding.Sick && plantationBuilding.SickPast && plantationBuilding.Health != 0)
{
plantationBuilding.Health -= plantationSeed.PenaltyForIllness;
Console.WriteLine($"-La plantacion {plantationBuilding.Name} se encuentra enferma y disminuyo la Salud a {plantationBuilding.Health}.");
}
else if (plantationBuilding.Sick)
{
Console.WriteLine($"-La plantacion {plantationBuilding.Name} se encuentra enferma.");
}
if (plantationBuilding.HasWorms && plantationBuilding.HasWormsPast && plantationBuilding.Health != 0)
{
plantationBuilding.Health -= plantationSeed.WormPenalty;
Console.WriteLine($"-La plantacion {plantationBuilding.Name} se encuentra con gusanos y disminuyo la Salud a {plantationBuilding.Health}.");
}
else if (plantationBuilding.HasWorms)
{
Console.WriteLine($"-La plantacion {plantationBuilding.Name} se encuentra con gusanos.");
}
if (plantationBuilding.HasUndergrowth && plantationBuilding.HasUndergrowthPast && plantationBuilding.Health != 0)
{
plantationBuilding.Health -= plantationSeed.WeedPenalty;
Console.WriteLine($"-La plantacion {plantationBuilding.Name} se encuentra con maleza y disminuyo la Salud a {plantationBuilding.Health}.");
}
else if (plantationBuilding.HasUndergrowth)
{
Console.WriteLine($"-La plantacion {plantationBuilding.Name} se encuentra con maleza.");
}
plantationBuilding.HasUndergrowthPast = plantationBuilding.HasUndergrowth;
plantationBuilding.HasWormsPast = plantationBuilding.HasWorms;
plantationBuilding.SickPast = plantationBuilding.Sick;
}
else if (building.GetType() == typeof(Livestock))
{
// Se actulizan datos de los ganados
Livestock livestockBuilding = building as Livestock;
Animal livestockAnimal = livestockBuilding.Animal;
livestockBuilding.Maturity += 1;
if (livestockBuilding.Health == 0)
{
Console.WriteLine($"-La salud del ganado {livestockBuilding.Name} llego a 0.");
}
//Agua
if (livestockBuilding.Water == 0)
{
Console.WriteLine($"-El nivel de agua del ganado {livestockBuilding.Name} llego a 0.");
}
else if (livestockBuilding.Water < livestockAnimal.MinimumWaterLevel && livestockBuilding.Health != 0)
{
livestockBuilding.Health -= livestockAnimal.PenaltyForLackOfWater;
Console.WriteLine($"-La salud del ganado {livestockBuilding.Name} disminuyo a {livestockBuilding.Health} debido a falta de Agua.");
}
//Comida
if (livestockBuilding.Food == 0)
{
Console.WriteLine($"-El nivel de alimentos del ganado {livestockBuilding.Name} llego a 0.");
}
if (livestockBuilding.Food < livestockAnimal.MinimumFoodLevel && livestockBuilding.Health != 0)
{
livestockBuilding.Health -= livestockAnimal.PenaltyForLackOfFood;
Console.WriteLine($"-La salud del ganado {livestockBuilding.Name} disminuyo a {livestockBuilding.Health} debido a falta de alimentos.");
}
if (livestockBuilding.Sick == false)
{
livestockBuilding.SickPast = false;
}
livestockBuilding.Escape();
livestockBuilding.SuddenDeath();
livestockBuilding.GetSick();
if (livestockBuilding.Sick && livestockBuilding.SickPast && livestockBuilding.Health != 0)
{
livestockBuilding.Health -= livestockAnimal.PenaltyForIllness;
Console.WriteLine($"-El ganado {livestockBuilding.Name} se encuentra enfermo y disminuyo la Salud a {livestockBuilding.Health}.");
}
else if (livestockBuilding.Sick)
{
Console.WriteLine($"-El ganado {livestockBuilding.Name} se encuentra enfermo.");
}
livestockBuilding.SickPast = livestockBuilding.Sick;
//consumos
if (livestockBuilding.Food != 0)
{
livestockBuilding.Food -= livestockAnimal.FoodConsumption;
}
if (livestockBuilding.Water != 0)
{
livestockBuilding.Water -= livestockAnimal.WaterConsume;
}
}
else if (building.GetType() == typeof(StorageBuilding))
{
//Se disminute la calidad de los productos almacenados
StorageBuilding storageBuilding = building as StorageBuilding;
storageBuilding.ChangeQuality();
}
}
turn += 1;
Console.ResetColor();
Console.WriteLine("Turno pasado...");
Console.WriteLine("Presione cualquier tecla para continuar...");
Console.ReadKey();
}
