public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
float waitTime;
if (outputChange.valueType == OutputChange.ValueType.Selector)
{
waitTime = outputChange.selector.GetFloatValue(agent, mapping);
}
else
{
waitTime = outputChange.floatValue;
}
if (outputChange.boolValue && waitTime != -1f)
{
waitTime *= agent.timeManager.RealTimeSecondsPerGameMinute();
}
Debug.Log(agent.name + ": WaitOCT - waiting for " + waitTime);
agent.behavior.SetIsWaiting(waitTime);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
// TODO: Feels like checks like these should be done once at start of game - InitCheck?
if (!(outputChange.unityObject is Material material))
{
Debug.LogError(agent.name + ": MappingType: " + mapping.mappingType.name + " - ChangeMaterialOCT: Material is invalid.");
return(false);
}
Renderer renderer = target.GetComponentInChildren <Renderer>();
if (renderer == null)
{
Debug.LogError(agent.name + ": MappingType: " + mapping.mappingType.name + " - ChangeMaterialOCT: target (" +
target.name + ") has no renderer.");
return(false);
}
Material oldMaterial = renderer.material;
renderer.material = material;
if (outputChange.floatValue > 0f)
{
agent.StartCoroutine(RevertMaterial(renderer, oldMaterial, outputChange.floatValue));
}
return(true);
}
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType,
InputCondition inputCondition, MappingType inputConditionMappingType)
{
List <InputCondition> inputConditionsFromOC = outputChangeMappingType.EntityTypeInputConditions();
List <EntityType> entityTypes = TypeGroup.PossibleEntityTypes(inputConditionsFromOC, agent.memoryType.GetKnownEntityTypes(agent));
if (inputConditionMappingType.AnyEntityTypeMatchesTypeGroups(entityTypes) &&
inputCondition.levelType == outputChange.levelType)
{
// Same EntityType and same TagType - match adding tag to needing tag and removing tag to can't have tag
if (!outputChange.boolValue &&
((HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.DoesNotHaveOwnerTag ||
(HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.DoesNotHaveTag))
{
return(true);
}
else if (outputChange.boolValue &&
((HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.HasTagButNotOwner ||
(HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.HasTagIgnoreOwnership ||
(HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.HasTagIsOwner))
{
return(true);
}
}
return(false);
}
// Returns the index of the first OutputChangeType that matches the InputConditionType or -1 if no matches
public int OutputChangeTypeMatch(InputCondition inputCondition, MappingType inputConditionMappingType, List <EntityType> allEntityTypes)
{
for (int i = 0; i < outputChanges.Count; i++)
{
OutputChange outputChange = outputChanges[i];
if (inputCondition.inputConditionType == null)
{
Debug.LogError("MappingType " + inputConditionMappingType.name + " has an InputCondition with no InputConditionType. Please Fix.");
return(-1);
}
if (outputChange.outputChangeType == null)
{
Debug.LogError("MappingType " + name + " has an OutputChange with no OutputChangeType. Please Fix.");
return(-1);
}
if (inputCondition.inputConditionType.matchingOCTs != null &&
inputCondition.inputConditionType.matchingOCTs.Contains(outputChange.outputChangeType) &&
outputChange.outputChangeType.PreMatch(outputChange, this, inputCondition, inputConditionMappingType, allEntityTypes))
{
return(i);
}
}
return(-1);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
if (mapping.target is Agent)
{
// TODO: This is really confusing - fix it and make sure it works
Agent otherAgent = target as Agent;
if (target == agent)
{
otherAgent = (Agent)mapping.target;
}
((Agent)target).memoryType.ChangeRLevel(((Agent)target), otherAgent, actualAmount);
}
else if (mapping.target is AgentEvent)
{
// TODO: Move this into AgentEvent so that it can decide how to handle RLevel changes
// Change this agent's R Level for all other attendees in this event
AgentEvent agentEvent = (AgentEvent)mapping.target;
foreach (AgentEvent.Attendee attendee in agentEvent.attendees)
{
if (agent != attendee.agent)
{
agent.memoryType.ChangeRLevel(agent, attendee.agent, actualAmount);
}
}
}
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
int intAmount = (int)actualAmount;
if (intAmount > 0)
{
int num = target.inventoryType.Add(target, outputChange.entityType, outputChange.intValue, null, intAmount);
if (num != intAmount)
{
Debug.LogError(target.name + ": InventoryCreateOCT only created " + num + "/" + intAmount + " of " + outputChange.entityType.name);
}
if (outputChange.levelType is TagType tagType)
{
// TODO: This isn't right - need to get the actual inventory enties created from Add above
Entity entity = target.inventoryType.GetFirstEntityofEntityType(target, outputChange.entityType);
entity.AddTag(tagType, target);
}
}
else if (intAmount < 0)
{
Debug.LogError("InventoryCreateOCT has a negative amount to take. Amount To Create must be positive.");
}
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
if (!agent.animationType.ImplementsAnimationRigging())
{
Debug.Log(agent.name + ": SetAnimationRigTargetOCT - agent's AnimationType does not implement AnimationRigging.");
return(true);
}
Vector3 position;
Quaternion rotation;
if (outputChange.targetType == OutputChange.TargetType.ToInventoryTarget)
{
position = mapping.inventoryTargets[outputChange.inventoryTypeGroupMatchIndex].transform.position;
position = agent.transform.InverseTransformPoint(position);
rotation = Quaternion.identity;
}
else if (outputChange.targetType == OutputChange.TargetType.ToSelf)
{
Transform transform = (Transform)outputChange.unityObject;
position = transform.position;
rotation = transform.rotation;
}
else
{
position = agent.transform.InverseTransformPoint(target.transform.position);
rotation = Quaternion.identity;
}
agent.animationType.WarpRigConstraintTargetTo(agent, (int)outputChange.floatValue, position, rotation);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
target.DestroySelf(agent);
return(true);
}
public override bool PreMatch(OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition,
MappingType inputConditionMappingType, List <EntityType> allEntityTypes)
{
// Matches OtherInventoryAmountICT
// This needs to be giving the corrent EntityType (InventoryGroupings) based on what the ICT needs (InventoryGroupings)
if (outputChange.inventoryTypeGroupMatchIndex == -1)
{
return(false);
}
InputCondition outputChangeInputCondition = outputChangeMappingType.inputConditions[outputChange.inventoryTypeGroupMatchIndex];
List <TypeGroup> groupings = outputChangeInputCondition.InventoryTypeGroups(outputChangeMappingType, out List <int> indexesToSet);
// groupings is now the EntityTypes that are possible to be given
List <EntityType> entityTypes = TypeGroup.InAllTypeGroups(groupings, allEntityTypes);
// See if any of these EntityTypes matches what the IC of OtherInventoryAmountICT needs
bool inventoryGroupMatches = inputCondition.AnyInventoryGroupingMatches(inputConditionMappingType, entityTypes);
// Also need to make sure that possible EntityTypes from both MappingTypes have some overlap
bool groupMatches = outputChangeMappingType.AnyEntityTypeMatchesTypeGroups(inputConditionMappingType, allEntityTypes);
if (inventoryGroupMatches && groupMatches)
{
return(true);
}
return(false);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
List <InventorySlot> inventorySlots = target.entityType.canBeInInventorySlots.Select(x => x.inventorySlot).ToList();
// TODO: Just drop it for now - do better logic later
List <InventorySlot> possibleSlots = inventorySlots.Intersect(agent.agentType.inventorySlots).ToList();
if (possibleSlots.Count == 0)
{
Debug.LogError(agent.name + ": ClearInventorySlotsOCT - unable to find a slot to clear.");
return(false);
}
// This will do nothing if the target doesn't have all of the amount
// TODO: Add in options to handle not enough inventory
InventoryType.Item item = target.inventoryType.Remove(target, possibleSlots[0]);
if (item == null)
{
return(false);
}
item.entity.inventoryType.Dropped(item.entity, item.inventorySlot);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
EntityType entityType = outputChange.entityType;
// If this is an AgentEvent location could need to be synced with WorldObject
// TODO: if self use inventory drop location?
Vector3 position = target.transform.position;
//int prefabVariantIndex = (int)outputChange.floatValue;
int prefabVariantIndex = 0;
if (entityType.prefabVariants == null || entityType.prefabVariants.Count <= prefabVariantIndex)
{
Debug.LogError(agent.name + ": CreateEntityOCT: " + entityType.name + " does not have enough Prefab Variants. " +
"Tried to access Prefab Variant Index = " + prefabVariantIndex + " - Please Fix.");
return(false);
}
GameObject newGameObject = entityType.CreateEntity(prefabVariantIndex, position, entityType.prefabVariants[prefabVariantIndex].transform.rotation,
entityType.prefabVariants[prefabVariantIndex].transform.localScale, agent);
Entity newEntity = newGameObject.GetComponent <Entity>();
if (outputChange.boolValue)
{
mapping.target = newEntity;
}
if (outputChange.floatValue > 0f)
{
newEntity.DestroySelf(null, outputChange.floatValue);
}
return(true);
}
private void RunOutputChanges(Agent agent, WorldObjectType.State newState, WorldObjectType.State currentState)
{
for (int i = 0; i < worldObjectType.statesOutputChanges.Count; i++)
{
OutputChange outputChange = worldObjectType.statesOutputChanges[i];
// currentState can be null on Start
if (newState.enterOutputChangesIndexes.Contains(i) || (currentState != null && currentState.exitOutputChangesIndexes.Contains(i)))
{
float amount = outputChange.outputChangeType.CalculateAmount(agent, this, outputChange, null);
if (!outputChange.CheckConditions(this, agent, null, amount))
{
Debug.Log(agent + ": WorldObject.RunOutputChanges - output conditions failed - " + this);
if (outputChange.stopType == OutputChange.StopType.OnOCCFailed)
{
return;
}
}
bool succeeded = outputChange.outputChangeType.MakeChange(agent, this, outputChange, null, amount, out bool forceStop);
Debug.Log(agent + ": WorldObject.RunOutputChanges - output condition " + outputChange.outputChangeType.name + " - " + succeeded);
if ((forceStop && !outputChange.blockMakeChangeForcedStop) ||
(outputChange.stopType == OutputChange.StopType.OnChangeFailed && !succeeded))
{
return;
}
}
}
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
int intAmount = (int)actualAmount;
if (intAmount > 0)
{
List <InventoryType.Item> items = target.inventoryType.Remove(target, outputChange.entityType, intAmount, true);
if (items == null || items.Count < intAmount)
{
Debug.LogError("InventoryDestroyEntityTypeOCT was unable to destroy EntityTypes (" + outputChange.entityType.name +
"). Only found " + (items == null ? "0" : items.Count.ToString()) + " out of " + intAmount + ".");
return(false);
}
foreach (InventoryType.Item item in items)
{
item.entity.DestroySelf(agent);
}
}
else if (intAmount <= 0)
{
Debug.LogError("InventoryDestroyEntityTypeOCT has a negative amount to take. Amount To Destroy must be positive.");
return(false);
}
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
// Make sure target is still there
// TODO: Do an in range check - not exactly sure what the range should be for pickup?
if (target.inEntityInventory != null)
{
Debug.Log(agent.name + ": InventoryPickupOCT - Target Entity " + target.name + " is gone.");
return(false);
}
InventorySlot inventorySlot;
if (outputChange.boolValue)
{
inventorySlot = agent.inventoryType.ClearSlotsAndAdd(agent, target);
}
else
{
inventorySlot = agent.inventoryType.Add(agent, target);
}
if (inventorySlot == null)
{
Debug.LogError(agent.name + ": InventoryPickupOCT unable to find inventorySlot for " + target.name);
return(false);
}
return(true);
}
public override float CalculateAmount(Agent agent, Entity target, OutputChange outputChange, Mapping mapping)
{
if (outputChange.valueType == OutputChange.ValueType.ActionSkillCurve)
{
return(outputChange.actionSkillCurve.Eval0to100(agent.ActionSkillWithItemModifiers(mapping.mappingType.actionType)));
}
return(outputChange.floatValue);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
((WorldObject)target).ChangeDamage(actualAmount);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
float actualChange = ((Agent)target).attributes[(AttributeType)outputChange.levelType].ChangeLevelRelative(actualAmount);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
// Near Entity change just passes target up to its parent - agent will be near the target after action (or recheck will fail for next mapping)
//if (mapping.parent != null)
// mapping.parent.target = mapping.target;
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
// TODO: Use animationType if agent?
Animator animator = target.GetComponentInChildren <Animator>();
// TODO: Feels like checks like these should be done once at start of game - InitCheck?
if (animator == null)
{
Debug.LogError(agent.name + ": MappingType: " + mapping.mappingType.name + " - SetAnimatorParamOCT: target " + target.name + " has no animator.");
return(false);
}
bool selectorValid = outputChange.selector.IsValid();
if (outputChange.stringValue == "" && !selectorValid)
{
Debug.LogError(agent.name + ": MappingType: " + mapping.mappingType.name + " - SetAnimatorParamOCT: Animator Param name " +
"String Value is blank and Selector is not valid. One of them must be set.");
return(false);
}
string paramName = outputChange.stringValue;
if (selectorValid)
{
paramName = outputChange.selector.GetEnumValue <string>(agent, mapping);
}
switch (outputChange.valueType)
{
case OutputChange.ValueType.None:
animator.SetTrigger(paramName);
break;
case OutputChange.ValueType.OppPrevOutputAmount:
animator.SetFloat(paramName, -mapping.previousOutputChangeAmount);
break;
case OutputChange.ValueType.PrevOutputAmount:
animator.SetFloat(paramName, mapping.previousOutputChangeAmount);
break;
case OutputChange.ValueType.BoolValue:
animator.SetBool(paramName, outputChange.boolValue);
break;
case OutputChange.ValueType.FloatValue:
animator.SetFloat(paramName, outputChange.floatValue);
break;
default:
break;
}
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
int intAmount = (int)actualAmount;
if (intAmount > 0)
{
// Figure out possible EntityTypes from ICs InventoryGroupings - just pick first one
List <EntityType> entityTypes;
if (outputChange.inventoryTypeGroupMatchIndex > -1 && outputChange.inventoryTypeGroupMatchIndex < mapping.mappingType.inputConditions.Count)
{
InputCondition inputCondition = mapping.mappingType.inputConditions[outputChange.inventoryTypeGroupMatchIndex];
entityTypes = inputCondition.GetInventoryTypeGroup().GetMatches(target.inventoryType.GetAllEntityTypes(target));
}
else if (outputChange.inventoryTypeGroupMatchIndex == -1)
{
entityTypes = TypeGroup.PossibleEntityTypes(mapping.mappingType.inputConditions, agent.inventoryType.GetAllEntityTypes(agent), true);
}
else
{
Debug.LogError(agent.name + ": InventoryDropOCT has an invalid value for inventoryGroupingMatchIndex in MT: " +
mapping.mappingType.name);
return(false);
}
if (entityTypes == null || entityTypes.Count == 0)
{
Debug.LogError(agent.name + ": InventoryDropOCT was unable to find an EntityType from ICs InventoryGroupings for MT: " +
mapping.mappingType.name);
return(false);
}
// TODO: Add in InventoryTFs to MTs
EntityType entityType = entityTypes[0];
// This will do nothing if the target doesn't have all of the amount
// TODO: Add in options to handle not enough inventory
List <InventoryType.Item> items = target.inventoryType.Remove(target, entityType, intAmount, true);
if (items == null)
{
return(false);
}
foreach (InventoryType.Item item in items)
{
// TODO: If Entity was created as Inventory it would have never gone through initialization
// so it won't have an inventoryType set. Make sure Entities created in inventory get initialized?
//item.entity.inventoryType.Dropped(item.entity, item.inventorySlot);
agent.inventoryType.Dropped(item.entity, item.inventorySlot);
}
}
else if (intAmount < 0)
{
Debug.LogError("InventoryDropOCT has a negative amount to take. Amount To Drop must be positive.");
}
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
EntityType inventoryTargetEntityType = mapping.inventoryTargets[outputChange.inventoryTypeGroupMatchIndex].entityType;
actualAmount = target.inventoryType.Add(target, inventoryTargetEntityType, 0, null, (int)actualAmount);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
Entity inventoryTargetEntity = mapping.inventoryTargets[outputChange.inventoryTypeGroupMatchIndex];
target.inventoryType.MoveInventorySlot(target, inventoryTargetEntity, outputChange.boolValue, true);
return(true);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
if (target is Agent targetAgent)
{
targetAgent.decider.InterruptMapping(false);
return(true);
}
return(false);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
int intAmount = (int)actualAmount;
if (intAmount > 0)
{
// Figure out possible EntityTypes from ICs InventoryGroupings - just pick first one
List <EntityType> entityTypes;
if (outputChange.inventoryTypeGroupMatchIndex > -1 && outputChange.inventoryTypeGroupMatchIndex < mapping.mappingType.inputConditions.Count)
{
InputCondition inputCondition = mapping.mappingType.inputConditions[outputChange.inventoryTypeGroupMatchIndex];
entityTypes = inputCondition.GetInventoryTypeGroup().GetMatches(agent.inventoryType.GetAllEntityTypes(agent));
}
else if (outputChange.inventoryTypeGroupMatchIndex == -1)
{
entityTypes = TypeGroup.PossibleEntityTypes(mapping.mappingType.inputConditions, agent.inventoryType.GetAllEntityTypes(agent), true);
}
else
{
Debug.LogError(agent.name + ": InventoryGiveOCT has an invalid value for inventoryGroupingMatchIndex in MT: " +
mapping.mappingType.name);
return(false);
}
if (entityTypes == null || entityTypes.Count == 0)
{
Debug.LogError(agent.name + ": InventoryGiveOCT was unable to find an EntityType from ICs InventoryGroupings for MT: " +
mapping.mappingType.name);
return(false);
}
// TODO: Add in InventoryTFs to MTs
EntityType entityType = entityTypes[0];
List <InventoryType.Item> items = agent.inventoryType.Remove(agent, entityType, intAmount, true);
int numGiven = target.inventoryType.Add(target, items);
if (numGiven != intAmount)
{
// TODO: Handle partial gives
// Failed to Give items for some reason - give back inventory to agent
agent.inventoryType.Add(agent, items);
Debug.Log(agent.name + ": InventoryGiveOCT was unable to give all to target. Tried to give " + intAmount + " - gave " + numGiven);
return(false);
}
}
else if (intAmount < 0)
{
Debug.LogError(agent.name + ": InventoryGiveOCT has a negative amount to take. Amount To Give must be positive.");
return(false);
}
return(true);
}
public override bool Check(ChangeCondition changeCondition, OutputChange outputChange, Agent agent,
Entity target, Mapping mapping, float actualAmount)
{
WorldObject worldObject = mapping.target as WorldObject;
if (worldObject != null && worldObject.isComplete == changeCondition.boolValue)
{
return(true);
}
return(false);
}
public override bool Check(ChangeCondition changeCondition, OutputChange outputChange, Agent agent,
Entity target, Mapping mapping, float actualAmount)
{
Agent targetAgent = mapping.target as Agent;
if (targetAgent != null && targetAgent.gender == Agent.Gender.Male && changeCondition.boolValue)
{
return(true);
}
return(false);
}
public override bool MakeChange(Agent agent, Entity target, OutputChange outputChange, Mapping mapping, float actualAmount, out bool forceStop)
{
forceStop = false;
if (agent.inAgentEvent == null)
{
return(false);
}
agent.QuitEvent();
return(true);
}
public virtual void RecordOutputChangeLog(Agent agent, Mapping mapping, OutputChange outputChange, float amount, bool succeeded)
{
agentsOutputChangeLogs[agent].Add(new OutputChangeLog()
{
time = Time.time,
mapping = mapping,
outputChange = outputChange,
amount = amount,
succeeded = succeeded
});
}
public override bool PreMatch(OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition,
MappingType inputConditionMappingType, List <EntityType> allEntityTypes)
{
// The EntityType being created need match with the ICMT's EntityType TypeGroup Target
List <TypeGroup> typeGroups = inputConditionMappingType.EntityTypeGroupings();
if (outputChange.entityType.InAllTypeGroups(typeGroups))
{
return(true);
}
return(false);
}
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType,
InputCondition inputCondition, MappingType inputConditionMappingType)
{
List <InputCondition> inputConditionsFromOC = outputChangeMappingType.EntityTypeInputConditions();
List <EntityType> entityTypes = TypeGroup.PossibleEntityTypes(inputConditionsFromOC, agent.memoryType.GetKnownEntityTypes(agent));
if (inputConditionMappingType.AnyEntityTypeMatchesTypeGroups(entityTypes))
{
return(true);
}
return(false);
}