private PropertyOwnership AddProperty(Property property, float value = 0) { PropertyOwnership newPropertyOwnership = new PropertyOwnership(property, value, owner); propertyOwnerships.Add(newPropertyOwnership); return(newPropertyOwnership); }
private bool RemoveProperty(PropertyOwnership propertyOwnership) { bool found = propertyOwnerships.Remove(propertyOwnership); if (found) { Debug.Log($"Removing property ownership ({propertyOwnership.ToString()}) from {owner}"); return(true); } Debug.LogWarning($"Trying to remove a property ({propertyOwnership.ToString()}) from '{owner}' that doesn't exist."); return(false); }
/// <summary> /// Looks for an ExecutionPlan to cover the Property in the given PropertyOwnership relation using the Properties this PropertyManager. /// </summary> /// <param name="propertyOwnershipToCover">The PropertyOwnership to which it is wanted to increase the value.</param> /// <param name="remainingValueToCover">The amount of value that is desired to increase with the obtained ExecutionPlan</param> /// <param name="executer">The MapElement that will execute the ExecutionPlan</param> /// <returns></returns> public ExecutionPlan GetExecutionPlanToCover(PropertyOwnership propertyOwnershipToCover, float remainingValueToCover, MapElement executer) { MapElement target = propertyOwnershipToCover.owner; // Debug.Log($" >>> Searching for an execution plan to cover '{remainingValueToCover}' of '{propertyOwnershipToCover.property}' owned by '{propertyOwnershipToCover.owner}' executed by '{executer}'.\n"); foreach (PropertyOwnership ownedProperty in propertyOwnerships) { foreach (MapEvent mapEvent in ownedProperty.property.mapEvents) { // Debug.Log($" >>> In '{ownedProperty.owner}', checking if mapEvent '{mapEvent}' in property '{ownedProperty.property}' can cover {remainingValueToCover} missing of the property '{propertyOwnershipToCover.property}'.\nTarget: {target}, Executer: {executer}, EventOwner still unknown.\n"); if (!mapEvent.executerMustOwnProperty || (mapEvent.executerMustOwnProperty && ownedProperty.owner == executer)) { MapElement eventOwner = ownedProperty.owner; ExecutionPlan executionPlan = new ExecutionPlan(mapEvent, executer, target, eventOwner, ownedProperty.property); executionPlan.SetExecutionTimesToCover(propertyOwnershipToCover, remainingValueToCover); int executionsToCover = executionPlan.executionTimes; if (executionsToCover < 0) // The executionPlan can not cover the property { continue; } Dictionary <PropertyOwnership, float> mapEventRequirementsNotMet = mapEvent.GetRequirementsNotMet(ownedProperty.property, executer, target, owner, executionPlan.executionTimes); if (mapEvent.tryToCoverRequirementsIfNotMet || (!mapEvent.tryToCoverRequirementsIfNotMet && mapEventRequirementsNotMet.IsNullOrEmpty())) { // If reached here, the mapEvent can be executed - Now choose if it is the appropriate one // Debug.Log($" > The mapEvent '{mapEvent}' can be executed ({mapEventRequirementsNotMet.Count} requirements must be covered before):\n - {mapEventRequirementsNotMet.ToStringAllElements("\n - ")}\n"); if (mapEvent.ConsequencesCover(propertyOwnershipToCover, target, executer, eventOwner, ownedProperty.property)) { Debug.Log($" ● Found Execution Plan: {executionPlan}\n"); return(executionPlan); } } } else { // Debug.Log($" The executer ({executer}) must own the property '{currentOwnedProperty.property}' to execute '{mapEvent}' but it does not. MapEvent owned by '{currentOwnedProperty.ownerMapElement}'.\n"); if (mapEvent.ConsequencesCover(propertyOwnershipToCover, target, executer, executer, ownedProperty.property)) { ExecutionPlan executionPlan = new ExecutionPlan(mapEvent, executer, target, executer, ownedProperty.property); executionPlan.SetExecutionTimesToCover(propertyOwnershipToCover, remainingValueToCover); Debug.Log($" ● Found 'forced' Execution Plan: {executionPlan}\n"); return(executionPlan); } } } } return(null); }
/// <summary> /// Updates the value of the PropertyOwnerships with the given Property. If no PropertyOwnerships related to the given Property is found, a new PropertyOwnerships will be created in this PropertyManager with the given value. /// </summary> /// <param name="propertyToUpdate">The Property that the updated PropertyOwnership must have.</param> /// <param name="deltaValue">The difference that is wanted to apply to the current value of the PropertyOwnership. Can be positive and negative.</param> public void UpdateProperty(Property propertyToUpdate, float deltaValue) { if (propertyToUpdate == null) { return; } PropertyOwnership foundPropertyOwnership = null; foreach (PropertyOwnership propertyOwnership in propertyOwnerships) { if (propertyOwnership.property != propertyToUpdate) { continue; } foundPropertyOwnership = propertyOwnership; foundPropertyOwnership.UpdateValue(deltaValue); //Debug.Log($" > The new value for the property '{managerProperty}' in '{ownerMapElement}' is = {managerProperty.value}"); } if (foundPropertyOwnership == null) { AddProperty(propertyToUpdate, deltaValue); // So, if the update was to add a new property } else { if (foundPropertyOwnership.value == 0) { if (foundPropertyOwnership.property == null) { Debug.LogError($"NULL PROPERTY IN {foundPropertyOwnership}. Error happened while trying to update the property {propertyToUpdate} with a delta value of {deltaValue}."); } else { switch (foundPropertyOwnership.property.behaviourWhenEmpty) { case BehaviourWhenEmpty.Remove: RemoveProperty(foundPropertyOwnership); break; case BehaviourWhenEmpty.TakeCare: // The care should be taken somewhere else break; case BehaviourWhenEmpty.DoNothing: break; case BehaviourWhenEmpty.Transform: foreach (PropertyOwnership inheritanceProperty in foundPropertyOwnership.property.inheritanceProperties) { AddProperty(inheritanceProperty.property, inheritanceProperty.value); } RemoveProperty(foundPropertyOwnership); break; default: throw new ArgumentOutOfRangeException(); } } } } }
public float GetValueOf(Property property) { PropertyOwnership foundProperty = GetOwnedPropertyAndAddItIfNotFound(property); return(foundProperty.value); }