package RTDB
using AIActionTarget

AIActionCondition
{
	fk< AIActionSubCondition > condition = "";
	fk< AISlotCond >[] slotOR = [];
	fk< AISlotCond >[] slotAND = [];
	fk< AIItemCond >[] inventoryOR = [];
	fk< AIItemCond >[] inventoryAND = [];
	fk< AIStatusEffectCond >[] statusEffectOR = [];
	fk< AIStatusEffectCond >[] statusEffectAND = [];
	fk< AISignalCond >[] signalOR = [];
	fk< AISignalCond >[] signalAND = [];
	fk< AISpatialCond >[] spatialOR = [];
	fk< AISpatialCond >[] spatialAND = [];
	fk< AIMovementCond >[] movementOR = [];
	fk< AIMovementCond >[] movementAND = [];
	fk< AIStatPoolCond >[] statPoolOR = [];
	fk< AIStatPoolCond >[] statPoolAND = [];
	fk< AIAmmoCountCond >[] ammoCountOR = [];
	fk< AIAmmoCountCond >[] ammoCountAND = [];
	fk< AIWeakSpotCond >[] weakSpotOR = [];
	fk< AIWeakSpotCond >[] weakSpotAND = [];
	fk< AIVehicleCond >[] vehicleOR = [];
	fk< AIVehicleCond >[] vehicleAND = [];
	fk< AISquadCond >[] squadAND = [];
	fk< AISquadCond >[] squadOR = [];
	fk< AICommandCond >[] commandAND = [];
	fk< AICommandCond >[] commandOR = [];
	fk< AIAbilityCond >[] ability = [];
	fk< AICooldownCond >[] cooldown = [];
	fk< AITresspassingCond >[] tresspassing = [];
	fk< AIRestrictedMovementAreaCond >[] restrictedMovementArea = [];
	fk< AIInTacticPositionCond >[] inTacticPosition = [];
	fk< AICalculateLineOfSightVector >[] calculateLineOfSightVector = [];
	fk< AICalculatePathCond >[] calculatePath = [];
	fk< AIStateCond >[] state = [];
	fk< AIReactionCond >[] reaction = [];
	fk< AILookAtCond >[] lookat = [];
	fk< AITargetCond > target = "";
	fk< AIOptimalDistanceCond > optimalDistance = "";
	fk< AIPreviousAttackCond > previousAttack = "";
	fk< AIBlockCountCond > blockCount = "";
	fk< AIDodgeCountCond > dodgeCount = "";
	fk< AIThrowCond > canThrow = "";
	fk< AIFriendlyFireCond > friendlyFire = "";
	fk< AIWeaponLockedOnTargetCond > weaponLockedOnTarget = "";
	fk< AICoverCond > cover = "";
	fk< AIGoToCoverCond > goToCover = "";
	fk< AIValidCoversCond > validCover = "";
	fk< AIHitCond > hit = "";
	fk< AIWorkspotCond > workspot = "";
	fk< AISecurityCond > security = "";
	fk< AIHasWeapon > weapon = "";
	fk< AINPCTypeCond > npcType = "";
}

AIActionSubCondition
{
	bool invert = false;
}

AIActionOR : AIActionSubCondition
{
	fk< AIActionSubCondition >[] OR = [];
}

AIActionAND : AIActionSubCondition
{
	fk< AIActionSubCondition >[] AND = [];
}

AIAbilityCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	fk< GameplayAbility >[] abilities = [];
}

AIHasWeapon : AIActionSubCondition
{
	CName itemTag = "";
	fk< ItemType >[] itemType = [];
	fk< ItemCategory >[] itemCategory = [];
}

AIReactionCond : AIActionSubCondition
{
	CName reactionBehaviorName = "";
	fk< ReactionPreset > preset = "";
	fk< StimType >[] stimType = [];
	fk< StatPool > thresholdValue = "";
	bool investigateController = false;
	bool validStimPosition = false;
}

AIWorkspotCond : AIActionSubCondition
{
	fk< AIActionTarget > workspotObj = "";
	int isInWorkspot = -1;
}

AISquadCond : AIActionSubCondition
{
	fk< AITicketType >[] hasTickets = [];
	fk< AITicketType >[] ticketsConditionCheck = [];
}

AICalculatePathCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
	Vector3 startPositionOffset = ( 0.f, 0.f, 0.f );
	bool checkStraightPath = false;
	bool checkDynamicObstacle = false;
	float distance = 0.f;
	float directionAngle = 0.f;
	float tolerance = 0.f;
	CName[] allowedOffMeshTags = 
	[
		"ChargeJump", "Jump", "Ladder", "OutOfCombatAction", "SearchExloration", "ThrusterJump"
	];
}

AICooldownCond : AIActionSubCondition
{
	fk< AIActionCooldown >[] cooldowns = [];
}

AICalculateLineOfSightVector : AIActionSubCondition
{
	fk< AIActionTarget > startPosition = "";
	fk< AIActionTarget > endPosition = "";
	bool ignoreNonPenetrableObj = true;
	Vector3 startPositionOffset = ( 0.f, 0.f, 0.f );
	Vector3 endPositionOffset = ( 0.f, 0.f, 0.f );
}

AIWeakSpotCond : AIActionSubCondition
{
	fk< Weakspot > weakspot = "";
	bool includeDestroyed = false;
}

AIHitCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	float hitTimeout = -1.f;
	int minHitSeverity = -1;
	int maxHitSeverity = -1;
	int hitDirection = -1;
	int targetHitCount = -1;
	int cumulatedDamageThreshold = -1;
	CName attackTag = "";
}

AIRestrictedMovementAreaCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
}

AITresspassingCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
	bool checkSafeArea = false;
}

AIFriendlyFireCond : AIActionSubCondition
{
	bool checkPlayer = false;
}

AITargetCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
	float minAccuracyValue = -1.0f;
	float minAccuracySharedValue = -1.0f;
	fk< AIAdditionalTraceType > isCombatTargetVisibleFrom = "AIAdditionalTraceType.Undefined";
	float minDetectionValue = -1.0f;
	float maxVisibilityToTargetDistance = -1.0f;
	int invalidExpectation = -1;
	int isVisible = -1;
	int isAlive = -1;
	int isActive = -1;
	int isMoving = -1;
	int attitude = -1;
}

AIStateCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	CName[] inStates = [];
	bool checkAllTypes = false;
}

AIThrowCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
	fk< AttachmentSlot > weaponSlot = "";
	float predictionTime = 0.f;
	float throwAngle = 0.f;
	float clearLOSDistanceTolerance = 0.f;
}

AIValidCoversCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	fk< AIRingType >[] limitToRings = [];
	int coversWithLOS = -1;
	bool checkCurrentlyActiveRing = false;
}

AICoverCond : AIActionSubCondition
{
	fk< AIActionTarget > owner = "AIActionTarget.Owner";
	fk< AIActionTarget > cover = "AIActionTarget.CurrentCover";
	fk< AIActionTarget > desiredCover = "AIActionTarget.DesiredCover";
	fk< AIActionTarget > target = "";
	int isProtectingHorizontallyAgainstTarget = -1;
	float predictionTime = 0.73f;
	int desiredCoverChanged = -1;
	int isOwnerExposed = -1;
	int isOwnerCrouching = -1;
	CName[] checkChosenExposureMethod = [];
	int hasAnyLastAvailableExposureMethods = -1;
	CName[] coverExposureMethods = [];
	float maxCoverToTargetAngle = -1.f;
	float minCoverHealth = 0.f;
	bool checkIfCoverTransitionRequired = false;
	int coverType = -1;
}

AIGoToCoverCond : AIActionSubCondition
{
	fk< AIActionTarget > cover = "AIActionTarget.SelectedCover";
	fk< AIActionTarget > desiredCover = "AIActionTarget.DesiredCover";
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	int isCoverSelected = -1;
	int isEnteringOrLeavingCover = -1;
	int desiredCoverChanged = -1;
}

AIPreviousAttackCond : AIActionSubCondition
{
	float timeWindow = -1.f;
	CName[] previousAttackName = [];
	int previousAttackDirection = -1;
}

AIBlockCountCond : AIActionSubCondition
{
	int ownerAttackBlockedCount = -1;
	int ownerAttackParriedCount = -1;
	int minBlockCount = -1;
	int maxBlockCount = -1;
	int minParryCount = -1;
	int maxParryCount = -1;
}

AIDodgeCountCond : AIActionSubCondition
{
	int minDodgeCount = -1;
	int maxDodgeCount = -1;
	int OwnerAttackDodgedCount = -1;
}

AIStatPoolCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	fk< StatPool > statPool = "";
	int isIncreasing = -1;
	Vector2 percentage = ( -1.f, -1.f );
}

AISpatialCond : AIActionSubCondition
{
	fk< AIActionTarget > source = "AIActionTarget.Owner";
	fk< AIActionTarget > target = "AIActionTarget.CombatTarget";
	fk< AIActionTarget > targetOpt = "";
	bool useTargetPOV = false;
	bool considerDirectionsOnly = false;
	float predictionTime = -1.f;
	Vector2 distance = ( -1.f, -1.f );
	Vector2 coneAngle = ( -1.f, -1.f );
	Vector2 zDiff = ( -1.f, -1.f );
	int angleDirection = 0;
	Vector3 spatialHintMults = ( 1.f, 1.f, 1.f );
}

AIExtendTargetCirclingCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.CombatTarget";
	fk< AIActionTarget > destinationTarget = "AIActionTarget.SelectedCover";
	float spreadIncreaseAngle = 0.f;
}

AIOptimalDistanceCond : AIActionSubCondition
{
	fk< AIActionTarget > source = "AIActionTarget.Owner";
	fk< AIActionTarget > target = "AIActionTarget.CombatTarget";
	bool failWhenCloserThanCurrentRing = false;
	bool failWhenFurtherThantCurrentRing = false;
	float predictionTime = -1.f;
	fk< AIRingType >[] checkRings = [];
	float distanceOffset = 0.f;
	float distanceMult = -1.f;
	float toleranceOffset = 0.f;
	float toleranceMult = -1.f;
}

AISignalCond : AIActionSubCondition
{
	CName name = "";
}

AIStatusEffectCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	fk< StatusEffect > statusEffect = "";
	fk< StatusEffectType > statusEffectType = "";
	CName gameplayTag = "";
}

AIItemCond : AIActionSubCondition
{
	fk< Item > itemID = "";
	CName itemTag = "";
	fk< ItemType > itemType = "";
	fk< ItemCategory > itemCategory = "";
	CName equipmentGroup = "";
	bool checkAllItemsInEquipmentGroup = false;
	fk< TriggerMode >[] triggerModes = [];
	fk< WeaponEvolution > evolution = "";
}

AISlotCond : AIItemCond
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	fk< AttachmentSlot > slot = "";
	int checkIfEmptySlotIsSpawningItem = -1;
	fk< TriggerMode > requestedTriggerModes = "";
}

AIAmmoCountCond : AIActionSubCondition
{
	fk< AttachmentSlot > weaponSlot = "";
	Vector2 percentage = ( -1.f, -1.f );
	int min = -1;
	int max = -1;
}

AIWeaponLockedOnTargetCond : AIActionSubCondition
{
	fk< AttachmentSlot > weaponSlot = "";
}

AICommandCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	CName[] hasCommands = [];
	CName[] hasNewOrOverridenCommands = [];
}

AIMovementCond : AIActionSubCondition
{
	Vector2 slope = ( -1.f, -1.f );
	CName movementType = "";
	CName moveLocomotionAction = "";
	fk< AIActionTarget > destination = "";
	Vector2 distanceToDestination = ( -1.f, -1.f );
	Vector3 spatialHintMults = ( 1.f, 1.f, 1.f );
	int pathFindingFailed = -1;
	int lineOfSightFailed = -1;
	int constrainedByRestrictedArea = -1;
	int isMoving = -1;
	int isEvaluated = -1;
	int isUsingOffMeshLink = -1;
	int isPauseByDynamicCollision = -1;
	int isDestinationCalculated = -1;
	int isDestinationChanged = -1;
	CName offMeshLinkType = "";
}

AIVehicleCond : AIActionSubCondition
{
	fk< AIActionTarget > vehicle = "AIActionTarget.Owner";
	fk< VehicleSeat >[] freeSlots = [];
	CName[] hasTags = [];
	int driverCheck = -1;
	Vector2 currentSpeed = ( -1.f, -1.f );
	Vector2 activePassangers = ( -1.f, -1.f );
}

AICanShootInCarChaseCond : AIActionSubCondition
{
}

AISecurityCond : AIActionSubCondition
{
	int isConnected = -1;
	fk< AIActionSecurityAreaType > areaType = "";
}

AINPCTypeCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	fk< NPCType >[] allowedNPCTypes = [];
	CName[] visualTags = [];
	int deviceState = -1;
	int isFollower = -1;
}

AILoSPositionCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	float maxRadiusXY = -1.f;
	float maxRadiusZ = 1.f;
	int type = 1;
	float maxNotFoundTime = 1.f;
}

AILookAtCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	int rightArmLookAtActive = -1;
}

AIVelocityCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	Vector2 range = ( 0.0f, -1.f );
	float timePeriod = 0.0f;
}

AIVelocityDotCond : AIActionSubCondition
{
	fk< AIActionTarget > velocityTarget = "AIActionTarget.Owner";
	fk< AIActionTarget > positionTarget = "AIActionTarget.CombatTarget";
	float timePeriod = 0.0f;
	Vector2 dotRange = ( -1.0f, 1.0f );
}

AIVelocitiesDotCond : AIActionSubCondition
{
	fk< AIActionTarget > firstTarget = "AIActionTarget.Owner";
	fk< AIActionTarget > secondTarget = "AIActionTarget.CombatTarget";
	float firstTimePeriod = 0.0f;
	float secondTimePeriod = 0.0f;
	Vector2 dotRange = ( -1.0f, 1.0f );
}

AIIsInActiveCameraCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	float height = 2.0f;
	float radius = 0.75f;
}

AIIsOnNavmeshCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	float radius = 0.0f;
}

AIIsFromDynamicSpawnSystem : AIActionSubCondition
{
}

AIIsFromPreventionSystem : AIActionSubCondition
{
}

AIIsHeatStage5Active : AIActionSubCondition
{
}

AITargetInPreventionFreeArea : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.CombatTarget";
}

AIIsShootingBlockedFromPrevention : AIActionSubCondition
{
}

AIGameDifficultyCond : AIActionSubCondition
{
	int comparedDifficulty = 0;
	CName comparisonType = "NotEqual";
}

AINPCDifficultyCond : AIActionSubCondition
{
	int comparedDifficulty = 0;
	CName comparisonType = "NotEqual";
}

AINPCRarityCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.Owner";
	string rarity = "";
}

AIInTacticPositionCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
	fk< AITacticType >[] tactics = [];
}

AIDriverCond : AIActionSubCondition
{
	fk< AIActionTarget > driver = "AIActionTarget.Owner";
}

AIAffiliationCond : AIActionSubCondition
{
	fk< Affiliation > affiliation = "";
}

AIInArmedVehicleCond : AIActionSubCondition
{
}

AIMovingInCirclesCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
	float range = -1.0f;
	float time = -1.0f;
}

AITargetStandingOnTopOfMovingVehicleCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "";
}

AITargetInUnmountingRangeCond : AIActionSubCondition
{
	fk< AIActionTarget > target = "AIActionTarget.CombatTarget";
}

AIEverPerformedChase : AIActionSubCondition
{
	fk< AIActionTarget > vehicle = "AIActionTarget.AssignedVehicle";
}

AIAssignedVehicleCanReachTargetCond : AIActionSubCondition
{
	fk< AIActionTarget > vehicle = "AIActionTarget.AssignedVehicle";
	fk< AIActionTarget > target = "";
	float duration = 0.0f;
}

AIAssignedVehicleInPanicDriving : AIActionSubCondition
{
	fk< AIActionTarget > vehicle = "AIActionTarget.AssignedVehicle";
}

AIAssignedVehicleInRace : AIActionSubCondition
{
	fk< AIActionTarget > vehicle = "AIActionTarget.AssignedVehicle";
}

AIPercentageChanceCond : AIActionSubCondition
{
	int successProbability = 0;
}

AIVehicleInsideInnerAreaOfAreaSpeedLimiter : AIActionSubCondition
{
	fk< AIActionTarget > vehicle = "";
}

