/// <summary>
/// Demande a la recette de s'executer pour une station donnee
/// </summary>
/// <param name="station"></param>
/// <param name="timestamp">l'heure en cours</param>
public bool ProduceOneBatch(Station station, int timestamp)
{
Hangar homeHangar = station.GetHangar(-1);
foreach (ResourceElement.ResourceType e in _inputs.Keys)
{
if (homeHangar.GetResourceQte(e) < _inputs[e])
{
return(false);
}
}
//toutes les inputs sont presentes
foreach (ResourceElement.ResourceType e in _inputs.Keys)
{
ResourceStack stack = homeHangar.GetStack(e, _inputs[e]);
}
foreach (ResourceElement.ResourceType e in _outputs.Keys)
{
//trouver tout les gens qui ont un standing
HashSet <int> withStanding = station.GetCorpWithStanding(e);
int qteToProd = _outputs[e];
foreach (int i in withStanding)
{
Hangar hisHangar = station.GetHangar(i);
if (null != hisHangar)
{
ResourceElement elem = new ResourceElement(e, station, qteToProd, timestamp);
ResourceStack stack = new ResourceStack(elem);
hisHangar.Add(stack);
}
}
}
return(true);
}
/// <summary>
/// Permet d'extraire un ResourceStack de ce stack.
/// Les ressources les plus anciennes seront priorisées et Qte sera retire de ce stack
/// </summary>
/// <param name="qte"></param>
/// <returns>un ResourceStack contenant Qte m3 ou null si ce n'est pas possible</returns>
public ResourceStack GetSubStack(int qte)
{
// Il faut si possible creer un stack qui contient les ressources les plus anciennes
// de ce stack et les enlever de ce stack. Il ne faut pas garder de resourceElement vide
if (qte > 0 && qte <= Qte)
{
ResourceStack subStack = new ResourceStack(Type);
foreach (ResourceElement re in _ResourceElementsInto)
{
if (subStack.Qte + re.Quantity < qte && re.Quantity > 0)
{
subStack.Add(re); // On ajoute l'élément entier.
}
else if (subStack.Qte < qte)
{
subStack.Add(re.Split(qte - subStack.Qte));
}
}
CleanResourceElementList();
onChange(this);
return(subStack);
}
else
{
return(null);
}
}
/// <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);
}
private void OnNewStack(OSTData.ResourceStack stack)
{
ResourceIcon obj = Instantiate <ResourceIcon>(iconPrefab);
obj.transform.SetParent(iconZone.transform);
obj.SetData(stack);
}
private void OnRemoveStack(OSTData.ResourceStack stack)
{
foreach (var s in iconZone.transform.GetComponentsInChildren <ResourceIcon>())
{
if (s.Stack.Type == stack.Type)
{
Destroy(s.gameObject);
}
}
}
/// <summary>
/// Ajout d'un ResourceStac a ce stack. Le stack passe en parametre sera vide
/// dans l'operation si le type de ressource est le meme.
/// </summary>
/// <param name="stack">Le stack a ajouter</param>
public void Add(ResourceStack stack)
{
if (stack.Type == Type)
{
for (int i = 0; i < stack._ResourceElementsInto.Count; i++)
{
Add(stack._ResourceElementsInto[i]);
}
stack.CleanResourceElementList();
}
onChange(this);
}
/// <summary>
/// demande de vendre tout ce qui peut l'etre sans depasser la quantite qu'on a decharge
/// </summary>
private void Sell()
{
Hangar myHangar = Ship.CurrentStation.GetHangar(Ship.Owner.ID);
Hangar stationHangar = Ship.CurrentStation.GetHangar(-1);
foreach (ResourceElement.ResourceType t in _unloaded.Keys)
{
if (Ship.CurrentStation.Buyings.Contains(t))
{
int qteToSell = Math.Min(_unloaded[t], myHangar.GetResourceQte(t));
if (qteToSell > 0)
{
ResourceStack s = myHangar.GetStack(t, qteToSell);
stationHangar.Add(s);
int qte = Ship.CurrentStation.GetBuyingPrice(t) * qteToSell;
Ship.Owner.AddICU(qte, "selling stuff");
}
}
}
}
/// <summary>
/// Permet d'ajouter un stack dans ce hangar. Le stack sera vide dans la transaction.
/// </summary>
/// <param name="stack">Le stack a ajouter.</param>
public void Add(ResourceStack stack)
{
ResourceStack inHangar = null;
for (int i = 0; i < ResourceStacks.Count; i++) //trouver si un stack de ce type existe, sinon en creer un
{
if (ResourceStacks[i].Type == stack.Type)
{
inHangar = ResourceStacks[i];
}
}
if (inHangar == null) // Il n'existait pas de stack dans le hangar.
{
ResourceStack s = stack.GetSubStack(stack.Qte);
ResourceStacks.Add(s); // Fait une copie dans le hangar et vide l'ancien stack
onNewStack(s);
}
else
{
inHangar.Add(stack); // Combine les stacks
}
}
private void OnChange(OSTData.ResourceStack s)
{
UpdateVisu();
}
public void SetData(OSTData.ResourceStack stack)
{
Stack = stack;
Stack.onChange += OnChange;
UpdateVisu();
}
