public bool IngestBurden(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver)
{
if (d_heldBurdens.ContainsKey(burden.category))
{
//this category is already held
//an instance of this type is already held, Process it and add it to the list.
Burden ReceiverTintedBurden = ReceiverTintBurden(burden, sender, receiver);
Burden IngestTintedBurden = IngestTintBurden(burden, sender, receiver);
d_heldBurdens[burden.category].Add(IngestTintedBurden);
}
else
{
d_heldBurdens.Add(burden.category, new List <Burden>()); //make the new category
Burden ReceiverTintedBurden = ReceiverTintBurden(burden, sender, receiver); //tint by receiver (character ingest action)
Burden IngestTintedBurden = IngestTintBurden(burden, sender, receiver); //tint by ingest (burden ingest action)
d_heldBurdens[burden.category].Add(burden); //add to receiver inventory
//this is a new burden we have not received yet. make a new info, new list, and add to it.
}
//a character should only ever have one copy of any type of burden. adding to that type increases the count in it.
//modifiedBurden.OwnerChangeNotice(this, true);
BurdensCollectionChanged();
//return true if the addition was compatible with the container, after adding.
return(true);
}
public static bool TransferBurden(Burden burden,CharacterBurdenManager sender, CharacterBurdenManager receiver)
{
//burden.BurdenPreSend(sender); //burden prepares for dispatch while inside first container.
//Strongly consider verifying the ability for sender and receiver to "pre-approve" the transfer. As it is very hard to undo.
//it would be nice to get a reason for the rejection, perhaps return some send/receive data on prevalidate.
if(!PrevalidateTransaction(burden, sender, receiver))
{
return false;
}
bool SendSuccess = sender.burdenInventory.DispatchBurden(burden,sender.burdenInventory,receiver.burdenInventory);
bool ReceiveSuccess = receiver.AddBurden(burden, sender, receiver);
if(SendSuccess && ReceiveSuccess)
{
Debug.Log("Burden transaction complete");
return true;
}
else
{
Debug.Log("Burden transaction failure to send from " + sender.burdenInventory.ContainerName + " to " + receiver.burdenInventory.ContainerName +
" of type " + burden.category.ToString());
return false;
}
}
public static bool PrevalidateTransaction(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver)
{
//if receiver is null, this is auto-true, as we are destroying the burden
bool canReceive = true;
//if sender is null, this is auto-true, as this is a new burden from the world.;
bool canSend = true;
if (sender != null)
{
if (!sender.canSendBurdens)
{
canSend = false;
}
}
if(receiver!=null)
{
if(!receiver.canReceiveBurdens)
{
canReceive = false;
}
}
if (burden.duplicateRule == Burden.CloneDuplicateRule.rejectAllDuplicateRequests && receiver.burdenInventory.d_heldBurdens.ContainsKey(burden.category))
{
Debug.Log("burden duplicate disallowed by configuration of parent burden. (category type was already held)");
//this is not necessarily a failure, as some burdens may accumulate while others cannot. Abort the transaction.
//be wary, this can infinite loop if paired with an aggressive queue.
//let the sender know their attempt was rejected, perhaps even add more flavorful data later.
sender.BurdenSendRejected(TransactionRejectionReasons.DuplicatesPrevented, sender, receiver, burden);
receiver.BurdenReceiveRejected(TransactionRejectionReasons.DuplicatesPrevented, sender, receiver, burden);
return false;
}
if (!canSend)
{
Debug.LogWarning("A burden transaction was rejected by SENDER : " + sender.burdenInventory.ContainerName);
sender.BurdenSendRejected(TransactionRejectionReasons.CharacterUnableToSend, sender, receiver,burden);
receiver.BurdenReceiveRejected(TransactionRejectionReasons.CharacterUnableToSend, sender, receiver,burden);
BurdenTransactionFailedLog(burden, sender, receiver, false);
return false;
}
if (!canReceive)
{
Debug.LogWarning("A burden transaction was rejected by RECEIVER : " + receiver.burdenInventory.ContainerName);
sender.BurdenSendRejected(TransactionRejectionReasons.CharacterUnableToReceive, sender, receiver, burden);
receiver.BurdenReceiveRejected(TransactionRejectionReasons.CharacterUnableToReceive, sender, receiver, burden);
BurdenTransactionFailedLog(burden, sender, receiver, false);
return false;
}
return true;
}
Burden IngestTintBurden(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver)
{
//Lets the burden's ingest behavior act, with reference to the sender and receiver so the burden can do things to them.
if (sender != null)
{
burden.BurdenIngestAction(sender.burdenInventory, this);
}
else
{
burden.BurdenIngestAction(null, this);
}
return(burden);
}
Burden ReceiverTintBurden(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver)
{
//tint based on receiving behaviors of the receiving inventory
BurdenProcess receiverOperation = BurdenTools.GetBurdenProcessReceiver(receiverType);
if (sender != null)
{
burden = receiverOperation(burden, sender.burdenInventory, receiver.burdenInventory);
}
else
{
burden = receiverOperation(burden, null, receiver.burdenInventory);
}
return(burden);
}
public bool AddBurden(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver)
{
//pre-validated add burden method, used on dynamic transactions
if (sender == null)
{
//this is a scripted send from a world source, use a more direct override. do not apply sender effects.
//apply receiver tint, and receive effects.
receiver.burdenInventory.IngestBurden(burden, receiver);
}
else
{
//include the sender in the logic to apply various effects.
receiver.burdenInventory.IngestBurden(burden, sender, receiver);
}
//the sender may not be another container.
return(true);
}
public bool TrySendBurden(Burden burden, CharacterBurdenManager target)
{
if (burden == null)
{
Debug.LogError("Tried to send a null burden. aborting");
return(false);
}
//can the target receive burdens? etc.
if (!canSendBurdens)
{
Debug.LogWarning(burdenInventory.ContainerName + " had a send burden request, but is not in a state they can.");
return(false);
}
else
{
//return true if send was a success.
return(BurdenTools.TransferBurden(burden, this, target));
}
}
public bool AddBurdenWorldSource(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver, bool overrideValidation = false)
{
//accessed by world sources to add a burden to the character.
//May or may not validate prior (some systems may necessitate overrides)
//this will commonly have a null sender, but in some cases, the sender may be an interactable object that can receive burdens and ideas.
if (!overrideValidation)
{
if (BurdenTools.PrevalidateTransaction(burden, sender, receiver))
{
receiver.burdenInventory.IngestBurden(burden, receiver);
return(true);
}
else
{
//prevalidation failed! validation will handle the debug logs.
return(false);
}
}
else
{
receiver.burdenInventory.IngestBurden(burden, receiver);
return(true);
}
}
//this overload is used when a sender does not exist. it will dispatch null to the various methods instead.
public bool IngestBurden(Burden burden, CharacterBurdenManager receiver)
{
return(IngestBurden(burden, null, receiver));
}
public void BurdenReceiveRejected(BurdenTools.TransactionRejectionReasons reason, CharacterBurdenManager sender, CharacterBurdenManager receiver, Burden burden)
{
//this character was to be sent a burden, but it failed with reason.
Debug.Log("burden transaction rejected with reason : " + reason.ToString());
}
public static void BurdenTransactionFailedLog(Burden burden, CharacterBurdenManager sender, CharacterBurdenManager receiver, bool queue = false)
{
//this is for error debugging, and not behavior.
Debug.LogWarning("A burden transaction failed between " + sender.burdenInventory.ContainerName + " and " + receiver.burdenInventory.ContainerName);
}
