/// <summary>
/// retire une certaine quantite d'une ressource dans un hangar. Les resources retirees sont toujours celles des
/// stacks les plus anciens.
/// </summary>
/// <param name="type">le type de resource a retirer</param>
/// <param name="qte"></param>
/// <returns>un stack qui contient la qte de resource du type si possible, null sinon</returns>
public ResourceStack GetStack(ResourceElement.ResourceType type, int qte)
{
if (GetResourceQte(type) < qte)
{
return(null);
}
ResourceStack currentStack = null;
foreach (ResourceStack s in ResourceStacks)
{
if (s.Type == type)
{
currentStack = s;
}
}
ResourceStack result = currentStack.GetSubStack(qte);
if (currentStack.Qte == 0)
{
onRemoveStack(currentStack);
ResourceStacks.Remove(currentStack);
}
return(result);
}
/// <summary>
/// Methode utilise par un vaisseau pour indiquer qu'il est en train de s'echarger d'un certain type de ressource
/// </summary>
/// <param name="ship"> Le vaisseau qui se charge</param>
/// <param name="type"> Le type de ressource qu'il charge</param>
public void InformLoading(Ship ship, ResourceElement.ResourceType type)
{
if (!_currentLoaders.ContainsKey(ship.Owner.ID))
{
_currentLoaders.Add(ship.Owner.ID, new HashSet <ResourceElement.ResourceType>());
}
_currentLoaders[ship.Owner.ID].Add(type);
}
/// <summary> recuperer le prix d'achat actuel pour une ressource dans cette station</summary>
/// <param name="type">la type a verifier</param>
/// <returns>le prix d'achat actuel en ICU</returns>
public int GetBuyingPrice(ResourceElement.ResourceType type)
{
if (_buyingPrices.ContainsKey(type))
{
return(_buyingPrices[type]);
}
return(0);
}
/// <summary>
/// Ajouter un output a cette recette. C'est a dire qu'une fois complete c'est qu'une quantite de ressource sera produite
/// </summary>
/// <param name="type">le type de ressource a produire</param>
/// <param name="qte">la qte de la ressource produite</param>
public void AddOutput(ResourceElement.ResourceType type, int qte)
{
if (!_outputs.ContainsKey(type))
{
_outputs.Add(type, 0);
}
_outputs[type] = qte;
}
/// <summary>
/// recuperer les besoins totaux pour un type de ressource pour cette recette
/// </summary>
/// <param name="type">le type de ressource demande</param>
/// <returns>la quantite necessaire</returns>
public int GetResourceNeed(ResourceElement.ResourceType type)
{
if (_inputs.ContainsKey(type))
{
return(_inputs[type]);
}
return(0);
}
/// <summary>
/// Permet de connaitre la quantite d'une ressource dans ce hangar.
/// </summary>
/// <param name="type">la ressource a tester.</param>
/// <returns>la quantite de m3 de la ressource demande.</returns>
public int GetResourceQte(ResourceElement.ResourceType type)
{
for (int i = 0; i < ResourceStacks.Count; i++)
{
if (ResourceStacks[i].Type == type)
{
return(ResourceStacks[i].Qte);
}
}
return(0);
}
/// <summary>
/// permet de savoir si une recette presente dans cette station produit des ressource du type donne
/// </summary>
/// <param name="type">le type a tester </param>
/// <returns>true si au moins une ressource produit de cette ressource</returns>
public bool IsProducing(ResourceElement.ResourceType type)
{
foreach (Receipe r in _receipies)
{
if (r.IsProducing(type))
{
return(true);
}
}
return(false);
}
/// <summary>
/// permet de recuperer le standing d'une corporation pour une ressource donnee dans cette station
/// </summary>
/// <param name="type">le type de ressource</param>
/// <param name="corporationID">l'ID de la corporation dont on veut le standing</param>
/// <returns>le standing de la corporation pour le type de ressource, defaultStanding si pas de standing</returns>
public float GetStanding(ResourceElement.ResourceType type, int corporationID)
{
if (_standings.ContainsKey(type))
{
if (_standings[type].ContainsKey(corporationID))
{
return(_standings[type][corporationID]);
}
}
return(defaultStanding);
}
/// <summary> ajuster le prix d'une ressource </summary>
/// <param name="type">le type de ressource a varier le prix</param>
/// <param name="newPrice">le nouveau prix d'achat</param>
public void SetBuyingPrice(ResourceElement.ResourceType type, int newPrice)
{
if (!_buyingPrices.ContainsKey(type))
{
_buyingPrices.Add(type, newPrice);
}
else
{
_buyingPrices[type] = newPrice;
}
}
/// <summary>
/// permet de modifier le standing d'une corporation en rapport a un type de ressource donne
/// </summary>
/// <param name="type">le type de ressource en question</param>
/// <param name="corporationID">le corpotation pour lequel le standing doit etre modifie</param>
/// <param name="standing">le nouveau standing de la corporation</param>
public void SetStanding(ResourceElement.ResourceType type, int corporationID, float standing)
{
if (!_standings.ContainsKey(type))
{
_standings.Add(type, new Dictionary <int, float>());
}
if (!_standings[type].ContainsKey(corporationID))
{
_standings[type].Add(corporationID, defaultStanding);
}
_standings[type][corporationID] = standing;
}
/// <summary>
/// permet de connaitre toutes les corps qui ont un standing > 0.01 sur un certain type de ressource
/// </summary>
/// <param name="type">la ressource a tester</param>
/// <returns>une liste d'ID de corp</returns>
public HashSet <int> GetCorpWithStanding(ResourceElement.ResourceType type)
{
HashSet <int> result = new HashSet <int>();
if (_standings.ContainsKey(type))
{
foreach (int k in _standings[type].Keys)
{
if (_standings[type][k] > 0.01)
{
result.Add(k);
}
}
}
return(result);
}
/// <summary>
/// Constructeur de base.
/// </summary>
/// <param name="type">Le type de ressource que pourra contenir ce stack </param>
public ResourceStack(ResourceElement.ResourceType type)
{
Type = type;
_ResourceElementsInto = new List <ResourceElement>();
}
/// <summary>
/// indique au vaisseau qu'une fois a cette destination, il devra decharger une certaine quantite de ressource
/// </summary>
/// <param name="type">le type de ressource</param>
/// <param name="qte">la qte a decharger</param>
public void AddUnload(ResourceElement.ResourceType type, int qte)
{
LoadData l = new LoadData(type, qte);
_unloads.Add(l);
}
/// <summary>
/// Constructeur avec valeurs
/// </summary>
/// <param name="iType"></param>
/// <param name="iQte"></param>
public LoadData(ResourceElement.ResourceType iType, int iQte)
{
type = iType; qte = iQte;
}
/// <summary>
/// Permet de connaitre si des outputs de cette recette produise un certain type de ressource
/// </summary>
/// <param name="type"> La ressource a tester</param>
/// <returns> true si la recette peut produire ce type de ressource </returns>
public bool IsProducing(ResourceElement.ResourceType type)
{
return(_outputs.ContainsKey(type));
}
