Emergency 2017 Dokumentation  v3.0.1
qsf::ai Namespace Reference

Namespaces

 detail
 
 direction
 
 EnsureKeepingEndpointDistance
 
 gridEntry
 
 move
 
 navigation
 
 operation
 
 path
 
 position
 
 reactionrules
 
 steering
 
 stuckResolve
 
 voronoi
 
 worldElement
 

Classes

class  AchieveLineOfSightGoal
 
class  ActorFactory
 Actor factory interface definition. More...
 
class  AiLodAccess
 
class  AiLodComponent
 
class  AiLodDebugGroup
 
class  AiLodSystem
 
struct  AllowsAllConflictsResolver
 
struct  AllowsNoConflictsResolver
 
class  Animation
 
class  ApproachedSpecialStateCallback
 
class  AreaConfiguration
 
class  AreaType
 
class  AreaTypeSerializer
 
class  AspectComponent
 An aspect component adds the ability to this entity to be perceived by sensor components attached to other entities. An aspect component contains any number of tags (for example "child,person"), in fact it is a wrapper around an AspectTags-object for direct use with the component system. An entity with such an aspect component can be perceived by any sensor component in range that's configured to react on at least one of those tags. More...
 
class  AspectTags
 Manages a list of aspect-tags. An aspect-tag is a string describing one aspect of an entity in the context of the sensor-/aspect-based perception system. You may specify any number of aspect-tags by supplying a comma-separated aspect-tag-list. Internally those are converted into a hash-list. AspectTags are used to configure aspect- and the sensor-components. A sensor reacts on entities supplied with a matching aspects. More...
 
class  AssetTypes
 Static QSF AI plugin asset types collection class. Has only static members so there is actually no need to ever create instances of this class. More...
 
class  AStar
 
class  AvoidancePoint
 
class  AvoidLineOfSightGoal
 
class  AvoidThreatsGoal
 
class  Bezier
 
class  BLAutoSingleton
 
class  BLSingleton
 Template implementation of the Singleton pattern. More...
 
class  BLVar
 
class  CalculateMapConnectionsTask
 
class  CircleTangentConnectionResult
 
class  CloseEntitiesTrackingComponent
 
class  CollisionAggregator
 Class that is used to aggregate collisions and keep track of the most critical one. It is used as a functor with several collision detection algorithms. The mode needs to be set before starting to test / integrate a number of collisions. Currently physical as well as reservation collisions are known modes. More...
 
class  CollisionCallback
 
class  CollisionInfo
 
class  CombinedPathSearchImplementation
 
class  CombinedSearchConnectionPoint
 
class  CompareVec
 
class  ConvertedStreetNetworkUpdateTask
 
class  Costs
 
class  CurveTurningResult
 
class  DebugParameters
 
class  DelayedReaction
 
class  DistanceGrid
 
class  DistanceGridCell
 
class  DynamicCollisionConverterComponent
 
class  DynamicCollisionLocalPlanner
 
class  DynamicNavigationBlockerComponent
 
class  DynamicPortal
 
class  DynamicPortalFunnelSmoother
 
class  DynamicTargetTracker
 
class  EActionFindPath
 
class  EActor
 EActor wrapper class for a QSF entity. More...
 
class  ECollisionBox
 Class to represent an oriented bounding box that is used for collision tests. The box is centered around its position. More...
 
class  ECollisionObject
 Base class for router collision objects. More...
 
class  ECollisionVObject
 
class  EdgePortal
 
class  EGenericObject
 EGenericObject wrapper class for a QSF entity. More...
 
class  EHouse
 EHouse wrapper class for a QSF entity. More...
 
class  ELocalMove
 
class  ELocalMovementState
 
class  EM3
 
class  EMultiPointTarget
 Class for a target which consist of multiple points. Reaching one of these points is desired. More...
 
class  EObject
 EObject wrapper class for a QSF entity. More...
 
class  EObjectTarget
 Class for a target that is an object. More...
 
class  EOrientedBox
 Class that implements an oriented box. The box is defined by extents, position and translation and is centered around its position. More...
 
class  EPathTest
 
class  EPerson
 EPerson wrapper class for a QSF entity. More...
 
class  EPointDistanceTarget
 Class for a target at a given point in a given distance. More...
 
class  EPointTarget
 Class for a target at a given point, with or without target-direction. More...
 
class  EPolygon
 
struct  EPolygonPoint
 
class  ERouteFinder
 Singleton class to compute routes. The class is also an interface (facade) to add, remove or change objects and streets to the router-environment. More...
 
class  ERouterEnvironment
 Class to store the environment that is used to compute routes. More...
 
class  ERouterLocalSearch
 Class that implements search for a path without using streets. More...
 
class  ERouterLocalSearchNode
 Helper class to store nodes from start to target. More...
 
class  ERouterObjectContainer
 Class to store obstacle objects for fast lookup for the router. More...
 
class  ERouterObjectState
 Simple storage class for object states used in the router. An object state consists of a position and a rotation. More...
 
class  ERouterPath
 Class to represent a path computed by the route-finder. More...
 
class  ERouterPathNode
 Class to represent a single node of the path. More...
 
class  ERouterPolygon
 Class to encapsulate and simplify computation of polygons to avoid obstacles. More...
 
class  ERouterSearch
 Base class of all searches of the router. More...
 
class  ERouterTarget
 Base class for all router targets. More...
 
class  ERouterTreeNode
 Class that implements a node of an n-ary tree. Usage: just inherit with the inheriting class as template paremeter. (e.g. class SearchNode : public ERouterTreeNode<SearchNode>) More...
 
class  ETerrain
 
class  ETerrainManager
 
class  ETraceableObjectTarget
 like EObjectTarget, but additionally a traceline checks if the way to the target is free More...
 
class  EvadedCollisionInfo
 
class  EvaluationParameters
 
class  EVehicle
 EVehicle wrapper class for a QSF entity. More...
 
class  EVehicleRoleInfo
 
class  EVirtualObject
 EVirtualObject wrapper class for a QSF entity. More...
 
class  ExportedProperty
 
class  FunnelDistanceEstimationResult
 
class  GeneralMetaclasses
 Static CAMP general plugin metaclass collection class. More...
 
class  GridBlocker
 
class  GridCellFunctor
 
class  GridConfiguration
 
class  GroupComponent
 
class  GroupMemberComponent
 
class  HeightRestriction
 
class  IndexedSearchState
 
class  InterMapConnections
 
class  Jobs
 Static QSF AI plugin jobs collection class. More...
 
class  Lane
 A single lane defines an atomic area where an entity might move along in the traffic lane representation. A lane is basically a point list with some free space projected to the sides of each line segment inside the navigation plane. This creates a series of connected and partially overlapping rectangular areas. Because the free space is available in all directions you need to add a semicircle at each segments end point to get the full picture. A lane may be connected at its endpoints to other lanes. More...
 
class  LaneBound
 
class  LaneCollection
 A collection of lanes. Some parts of the lane representation are stored inside this compound structure for saving memory. Because these are the basic data types for the AI world representation creating an instance for each element which would have its own dynamic containers would probably be a noticeable overhead. More...
 
class  LaneEndNode
 
class  LaneNode
 
class  ManagedNavigationMap
 
class  ManagedNavigationMapReadAccess
 
class  ManagedNavigationMapWriteAccess
 
class  MapContactPoint
 
class  MinMaxDelay
 
class  MinMaxDuration
 
class  MoveAction
 
class  MovementMode
 
class  MultipleSensorsComponent
 A sensor component with any number of sensor-configurations. Entities equipped with such a sensor gain the ability to detect other entities with a matching aspect-component / matching components attached. A MultipleSensorsComponent has to be used in cases where one sensor is not enough and cannot be handled by one sensor with multiple aspect-tags. More...
 
class  NavigationComponent
 
class  NavigationComponentCollision
 
class  NavigationDebugGroup
 
class  NavigationDummyTask
 
class  NavigationElementConnector
 
class  NavigationGoal
 
class  NavigationGoalFactory
 
class  NavigationMapUpdateConfiguration
 
class  NavigationMetaclasses
 Static CAMP general plugin metaclass collection class. More...
 
class  NavigationTargetPoint
 
class  NavigationTask
 
class  NavigationTaskStatistics
 
class  NavigationTaskThread
 
class  NavigationWorldModel
 
class  ObstructingCollision
 
class  OuterMapBoundaries
 
class  Path
 
class  PathfindingSystem
 
class  PathSearch
 
class  PathSearchConfiguration
 
class  PathSmoothing
 
class  Perception
 A perception describes an entity perceived by a sensor. It also contains information on the perception's state. More...
 
class  PerceptionDebugGroup
 Encapsulates the configurations for all available debugging options inside the AI sensor perception system. Noncopyable by inheritance. More...
 
class  PerceptionEvent
 A PerceptionEvent is used to communicate perception-information, usually from sensor-components to reaction-components. It contains information about the perceived entity, the perceiver, the perception's state and an ID to give the event a name. More...
 
class  PerceptionEventAction
 
class  PerceptionEventQueue
 A PerceptionEventQueue holds any number of PerceptionEvents in the order at which they were pushed into it. It also allows to iterate over its queued events selectively. More...
 
class  PersonEvadeToTheSideLogic
 
class  PlanActions
 
class  Plugin
 Artificial Intelligence (AI) plugin implementation. More...
 
class  ProcessingParameters
 processing-parameters are a convenient helper for supplying all necessary fixed parameters for a sensor-update-run in one place. It automatically extracts, validates and cashs additional information from the entity whose sensor is to be updated. More...
 
class  ReachConsecutivePointGoal
 
class  ReachMultiPointGoal
 
class  ReachObjectGoal
 
class  ReachSinglePointGoal
 
class  Reaction
 
class  ReactionComponent
 
class  ReactionDebugGroup
 
class  ReactionPool
 
class  ReactionPoolAdder
 
class  ReactionRule
 
class  ReactionRuleCloneable
 
class  ReactionRuleHandlerEmpty
 
class  ReactionRuleHandlerScript
 
class  ReactionRulesTable
 
class  ReactionRulesTableAdder
 
class  ReactionRulesTableSerializer
 
class  ReactionRuleWithHandlers
 
class  ReactionSystem
 
class  ReinitializeDistanceMapTask
 
class  Reservation
 
struct  ReservationConflictResolver
 This defines the interface for a functor that you need to provide in your specific implementation. It is called every time there is a collision between a new reservation and older existing ones. More...
 
class  ReservationContainer
 
class  ReservationSystem
 
class  RouterComponent
 
class  RouterScene
 
class  RouterTimer
 
class  SearchContactPoint
 
class  SearchItem
 
class  SearchMechanics
 
struct  SearchStateCostMore
 
class  SearchStepToIgnore
 
class  SensorComponent
 The base class for all sensor-components. Currently two types of sensors exist, derived from this class: More...
 
class  SensorConfiguration
 A sensor-configuration contains all necessary information to configure a sensor or a part of a multiple-sensor. It defines a sensor's position and range relative to the entity the corresponding sensor is attached to. It holds an aspect-tags object to configure what kind of entities the sensor should detect. The aspect-tags can either be used to scan for entities with a matching AspectComponent or for entities equipped with certain components by interpreting the aspect-tags as component class names. It also allows to configure an optional line-of-sight-check, so that only non-occluded entities are actually perceived (while also allowing to "look through" certain obstacles). A sensor-configuration also holds the perceptions resulting from an update. More...
 
class  SensorConfigurationSerializer
 Class to (de)serialize one or multiple sensor-configurations. More...
 
class  SensorPerceptionSystem
 Standard-system that manages SensorComponents. More...
 
class  SimpleBarrierComponent
 
class  SimplePathSearchImplementation
 
class  SimpleSearchState
 
class  SimpleTangentConnectionResult
 
class  SingleSensorComponent
 A sensor component with one single sensor-configuration. Entities equipped with such a sensor gain the ability to detect other entities with a matching aspect-component / matching components attached. More...
 
class  SpatialConfiguration
 
class  SpeedLimitFunctor
 
class  StandardSystem
 
class  StaticSearchSpace
 
class  SteeringSystem
 
class  StuckResolverComponent
 
class  StuckResolvingSystem
 
class  SystemComponent
 abstract super class for systems realized as singleton components. More...
 
class  TemporaryObstacleData
 
class  TrafficControlSystem
 
class  TrafficLaneNavigation
 Provides the search mechanics details for navigating on a world description made up of traffic lanes. More...
 
class  TrafficLaneSearchSpace
 
class  TrafficLaneSearchState
 
class  TrafficLaneWorld
 Describes a world abstraction made up of connected traffic lanes. Traffic lane worlds may be edited manually or created automatically by the Voronoi graph creation process. This is signaled by the automatic creation parameters being present or absent. Non copyable like all world models by inheritance. More...
 
class  TrafficLaneWorldBinarySerializer
 
class  TrafficLaneWorldCreationSettings
 An instance of this class keeps track the settings that were used to create a specific traffic lane world. More...
 
class  TrafficLaneWorldSerializer
 
class  TrafficLightComponent
 
class  TrafficLightPhaseConfiguration
 
class  TrafficLightPhaseSchedule
 
class  TrafficLightPhaseScheduleJsonSerializer
 Contains static functions for reading and writing a traffic light phase schedule from or to Json text format. More...
 
class  TrafficLightTimerComponent
 
class  TurningConfiguration
 
class  TurningConstraint
 
class  TurnToPerceiver
 
class  UnsignedFloatCosts
 
class  UsedTransitionData
 
class  VehicleEvadeToTheSideLogic
 
class  VoronoiBasedMapUpdateTask
 
class  Waypoint
 
class  WeightedSearchContactPoint
 
struct  WeightedState
 
class  WorldElementStateCollection
 
class  WorldModel
 
class  WorldModelManager
 
class  WorldModelSerializer
 

Typedefs

typedef boost::optional< DebugParametersDebugSetting
 
typedef SpatialConfiguration< glm::vec2 > SpatialConfiguration2D
 
typedef SpatialConfiguration< glm::vec3 > SpatialConfiguration3D
 
typedef int ERouterFlagsSet
 
typedef int ECollisionTypeSet
 
typedef int ERouterTraceLineFlagsSet
 
typedef std::vector< ECollisionObject * > CollisionObjectArray
 
typedef std::unordered_map< EActor *, CollisionObjectArrayCollisionObjectMap
 
typedef std::unordered_map< int, ECollisionObject * > CollisionObjectIdMap
 
typedef std::unordered_set< ECollisionObject * > CollisionList
 
typedef std::vector< PerceptionEventPerceptionEventContainer
 
typedef glm::tvec2< unsigned int, glm::defaultp > GridCoordinates
 
typedef glm::tvec2< int, glm::defaultp > GridDelta
 
typedef LaneNode< glm::vec3 > LaneNode3D
 
typedef LaneNode< glm::vec2 > LaneNode2D
 
typedef std::deque< WaypointPathUnderConstruction
 
typedef SpatialConfiguration< glm::vec3 > TurningPoint
 

Enumerations

enum  EActionFindPathState {
  EFP_INITIAL, EFP_SEARCH_PATH, EFP_SEARCH_FRONT_PATH, EFP_SEARCH_BACK_PATH,
  EFP_MOVE, EFP_ABORT, EFP_DONE
}
 
enum  EActionFindPathFlags { EFPF_NONE = 0x0000, EFPF_IGNORE_HYDRANTDISTANCE = 0x0001, EFPF_NOCURVES = 0x0002 }
 
enum  EPolygonOrientation { EPO_CW, EPO_CCW }
 
enum  ECollisionBoxType { ECB_STATIC, ECB_DYNAMIC, ECB_DYNAMIC_MOVING, ECB_VIRTUAL }
 
enum  ERouterFlags {
  ERF_NONE = 0, ERF_STATIC_OBJECTS = 0x01, ERF_IGNORE_MOVING_OBJECTS = 0x02, ERF_IGNORE_WATER = 0x08,
  ERF_IGNORE_CIVILIANS = 0x10, ERF_IS_LF = 0x100, ERF_ONLY_DIRECT_WAY = 0x200, ERF_NO_BACKWARDS = 0x1000,
  ERF_NOCURVES = 0x8000, ERF_IGNORE_CARRIER = 0x10000, ERF_DONT_IGNORE_OWNER = 0x80000, ERF_IGNORE_FOLLOWERS = 0x100000,
  ERF_IGNORE_UNMOVED = 0x200000, ERF_UNMOVED_NOSTATICFLAG = 0x400000
}
 
enum  ECollisionType { ERFCT_NONE = 0, ERFCT_MOVINGOBJECT = 0x01, ERFCT_STATICOBJECT = 0x02, ERFCT_POTENTIALMOVINGOBJECT = 0x04 }
 
enum  ERouterTraceLineFlags { RTLF_NONE = 0, RTLF_IGNORE_NONENEMY_UNITS = 0x01 }
 
enum  SearchItemType { SIT_STRAIGHT, SIT_CURVE, SIT_SHUNTING, SIT_STRAIGHTSHUNTING }
 
enum  EMoveTypes { EMT_NONE = 0, EMT_FORWARD = 0x01, EMT_BACKWARD = 0x02, EMT_STRAIGHTSHUNTING = 0x04 }
 
enum  ERouterPathType { RPT_NONE, RPT_NORMAL, RPT_BEZIER }
 
enum  ERouterSearchType { ER_NO_SEARCH, ER_LOCAL_SEARCH }
 
enum  ERouterSearchResult {
  ERSR_FAILED, ERSR_FAILED_CANCELED, ERSR_SUCCESS, ERSR_SUCCESS_WITHLIMIT,
  ERSR_COMPUTING
}
 
enum  ERouterTargetType {
  ERT_NONE, ERT_POINT_TARGET, ERT_POINT_DISTANCE_TARGET, ERT_MULTI_POINT_TARGET,
  ERT_OBJECT_TARGET, ERT_TRACEABLE_OBJECT_TARGET, _ERT_NUM_TARGET_TYPES
}
 
enum  ERouterTurnMode { ETM_NONE, ETM_TURNTO, ETM_TURNFROM }
 
enum  EObjectTerrainClass {
  EOTC_ANYTHING, EOTC_CAR, EOTC_TRUCK, EOTC_OFFROAD,
  EOTC_TRACKVEHICLE, EOTC_BOAT, EOTC_SHIP, EOTC_DIVER,
  EOTC_AIRPLANE, EOTC_CIVILIAN, EOTC_SQUAD, EOTC_SQUADCAR,
  EOTC_HELILANDING, EOTC_ANIMAL, EOTC_VIRTUALFLOOR, EOTC_TRAFFIC,
  EOTC_SHOOTABLE, EOTC_SEETHROUGH, EOTC_FORCESTREET, EOTC_RESCUEDOG,
  _EOTC_NUMCLASSES, EOTC_INVALID
}
 
enum  EActorType {
  EAT_UNKNOWN = 0x00000001, EAT_FLOOR = EAT_UNKNOWN, EAT_OBJECT = 0x00000002, EAT_HOUSE = 0x00000004,
  EAT_VEHICLE = 0x00000008, EAT_PERSON = 0x00000010, EAT_LIQUID = 0x00000020, EAT_VIRTUAL = 0x00000040,
  EAT_ALL = 0xFFFFFFFF, EATF_GENERICOBJECT = EAT_OBJECT | EAT_HOUSE | EAT_VEHICLE | EAT_PERSON
}
 
enum  ETargetPoint {
  ETP_ANY, ETP_EQUIPMENTDOOR, ETP_SHEARSDOOR, ETP_SHEARSDOOR_OFFSET,
  ETP_PASSENGERDOOR, ETP_REARDOOR, ETP_FIREHOSE_HOOKUP, ETP_ENGINE,
  ETP_EXTINGUISH, ETP_EXTINGUISHHOSE, ETP_ENGINE_EXTINGUISH, ETP_AXE,
  ETP_CHAINSAW, ETP_ENTRANCEDOOR, ETP_MEGAPHONE_DISTANCE, ETP_DLK_BASKET,
  ETP_LOADUP, ETP_ENTRY_WINDOW_PARKING, ETP_DLK_BASKET_BASE, ETP_TREATMENT,
  ETP_UNLOAD, ETP_ENTRY_WINDOW, ETP_INSTALL_FGRB, ETP_SHOOT,
  ETP_FOLLOW, ETP_DLK_EXTINGUISH, ETP_UNLOAD_TFMB, ETP_FLAME_EFFECT,
  ETP_FLAME_EFFECT_INACTIVE, ETP_FLAME_EFFECT_INHOUSEFIRE, ETP_CROSS_BRIDGE, ETP_OPPOSITE_BRIDGE,
  ETP_EXTINGUISH_PERSON, ETP_TOUCHPERSON, ETP_USE, ETP_OBJECTSURFACE,
  ETP_FREE_CONNECTOR, ETP_RANDOM, ETP_HOUSE_SAFE_DISTANCE, ETP_PUTFOLLOWERINCAR,
  ETP_MAX
}
 
enum  EObjectFlag {
  EOF_NONE = 0x00000000, EOF_PERSON_ENCLOSED = 0x00000001, EOF_LOCKED = 0x00000002, EOF_USABLE = 0x00000004,
  EOF_BULLDOZABLE = 0x00000008, EOF_TRANSPORTABLE = 0x00000010, EOF_PULLABLE = 0x00000020, EOF_ACCESSIBLE = 0x00000040,
  EOF_COOLABLE = 0x00000080, EOF_SHOOTABLE = 0x00000100, EOF_CUTABLE = 0x00000200, EOF_USABLE_WITH_MEGAPHONE = 0x00000400,
  EOF_RECOVERABLE = 0x00000800, EOF_FLOTSAM = 0x00001000, EOF_HIDDEN = 0x00002000, EOF_CARRYABLE_BY_BULLDOZER = 0x00008000,
  EOF_HAS_FIRE_EXTINGUISHER = 0x00010000, EOF_HAS_SHEARS = 0x00020000, EOF_HAS_CHAINSAW = 0x00040000, EOF_HAS_HOSE = 0x00080000,
  EOF_HAS_JUMPPAD = 0x00100000, EOF_HAS_ROADBLOCK = 0x00200000, EOF_HAS_FLASHGRENADE = 0x00400000, EOF_HAS_FIREAXE = 0x00800000,
  EOF_EMERGENCY = 0x01000000, EOF_ININACCESSIBLEAREA = 0x40000000, EOF_BLOCKED = 0x80000000
}
 
enum  EFloorPlacement {
  EFP_NONE, EFP_AXISALIGNED, EFP_BOXALIGNED, EFP_ALIGNED_CORNERS,
  EFP_ALIGNED_SAMPLED, EFP_PHYSICS, EFP_CUSTOM_PLACEMENT, EFP_ALIGNED_CORNERS_FLOOR
}
 
enum  EPersonRole {
  EPR_UNKNOWN, EPR_CIVILIAN, EPR_SQUAD, EPR_GANGSTER,
  EPR_DROWNING, EPR_ANIMAL, EPR_PARAMEDIC
}
 
enum  EVehicleRole2 {
  EVR2_NOTASK, EVR2_THW_FGRR_BKF, EVR2_THW_FGRB_BLF, EVR2_THW_FGRI_EKW,
  EVR2_FIREFIGHTERS_ASF, EVR2_FIREFIGHTERS_DEKONP, EVR2_FIREFIGHTERS_DLK, EVR2_FIREFIGHTERS_RW,
  EVR2_FIREFIGHTERS_TLF, EVR2_FIREFIGHTERS_LF, EVR2_FIREFIGHTERS_FLB, EVR2_FIREFIGHTERS_LPF,
  EVR2_FIREFIGHTERS_FMB, EVR2_FIREFIGHTERS_TFMB, EVR2_POLICE_SW, EVR2_POLICE_MTW,
  EVR2_POLICE_PHC, EVR2_POLICE_STW, EVR2_POLICE_WAW, EVR2_POLICE_GETAWAY,
  EVR2_AMBULANCE_ITW, EVR2_AMBULANCE_NEF, EVR2_AMBULANCE_RHC, EVR2_AMBULANCE_RHF,
  EVR2_AMBULANCE_RTW, EVR2_TAXI, EVR2_BUS, EVR2_DRIVERCAR,
  EVR2_GANGSTER_GETAWAY, EVR2_TV_HELI, EVR2_FIREFIGHTERS_TLF_HISTORIC, EVR2_THW_FGRR_RL = 100,
  EVR2_THW_FGRR_TRL = 101, EVR2_THW_FGRT_BH = 102, EVR2_FIREFIGHTERS_GTF = 200, EVR2_FIREFIGHTERS_LFKF,
  EVR2_FIREFIGHTERS_LFKF_HELI, EVR2_FIREFIGHTERS_LF_HELI, EVR2_POLICE_GTW = 300, EVR2_POLICE_SEKHC,
  EVR2_POLICE_SEKDF, EVR2_POLICE_SEKD, EVR2_AMBULANCE_TRANSEVAC = 400, EVR2_FIREFIGHTERS_FWDF = 410,
  EVR2_FIREFIGHTERS_FWD, EVR2_ALL_SQUAD_VEHICLES = 500, EVR2_NUMTYPES = EVR2_TV_HELI + 11, _EVR2_NUMTYPES_EM2012 = EVR2_TV_HELI + 9
}
 
enum  PerceptionState { PERCEPTION_BEGAN = 0, PERCEPTION_CONTINUED, PERCEPTION_ENDED }
 The PerceptionState describes which state the perception is in. More...
 

Functions

template<typename Action >
void calculateIntersectedCells (glm::vec2 lineStart, glm::vec2 lineEnd, const GridConfiguration &gridConfig, Action &action, UnsignedFloat snapVertexDelta)
 
template<typename Action >
void calculateIntersectedCells (const GridCoordinates &startIndices, const GridCoordinates &goalIndices, Action &action, UnsignedFloat snapVertexDelta)
 
area::PointRelation isInsideConvexPolygon (const glm::vec2 &point, const glm::vec2 *polygonFirst, const glm::vec2 *polygonLast)
 
float distanceToConvexPolygon (const glm::vec2 &point, const glm::vec2 *polygonFirst, const glm::vec2 *polygonLast)
 
template<typename Vector >
UnsignedFloat calculateRadiusOfCircle (const Vector &tangentPosition, const Vector &tangentDirection, const Vector &secondTangentPosition)
 
glm::vec2 calculateTangentDirection (const glm::vec2 &pointOnCircle, const glm::vec2 &midPoint, bool clockwiseTurn, const PlanarProjector< float > &projector)
 
std::pair< glm::vec2, glm::vec2 > calculateTangentPointsOnCircle (const glm::vec2 &midPoint, UnsignedFloat radius, const glm::vec2 &tangentDirection)
 
QSF_AI_API_EXPORT glm::vec2 calculateTangentPointOnCircle (const glm::vec2 &midPoint, UnsignedFloat radius, const glm::vec2 &desiredDirection, bool clockwiseRotation, const PlanarProjector< float > &projector)
 
QSF_AI_API_EXPORT Radians calculateAngleInDirection (const glm::vec2 &firstPoint, const glm::vec2 &secondPoint, bool clockwise, const PlanarProjector< float > &projector)
 
QSF_AI_API_EXPORT UnsignedFloat calculateLengthOnCircle (const glm::vec2 &firstPoint, const glm::vec2 &secondPoint, bool clockwise, const PlanarProjector< float > &projector, boost::optional< UnsignedFloat > radius=boost::optional< UnsignedFloat >())
 
QSF_AI_API_EXPORT glm::vec2 movePointOnCircle (const glm::vec2 &current, const TurningConfiguration &turningConfig, UnsignedFloat distance, const PlanarProjector< float > &projector)
 
QSF_AI_API_EXPORT unsigned int calculateCircleCircleIntersection (const glm::vec2 &center1, UnsignedFloat radius1, const glm::vec2 &center2, UnsignedFloat radius2, glm::vec2 *intersection1=nullptr, glm::vec2 *intersection2=nullptr, UnsignedFloat epsilon=1e-4f)
 
QSF_AI_API_EXPORT unsigned int calculateCircleLineIntersectionAsDirectionFactor (const glm::vec2 &center, UnsignedFloat radius, const Line2D &line, float *directionFactorSolution1=nullptr, float *directionFactorSolution2=nullptr)
 
QSF_AI_API_EXPORT unsigned int calculateCircleLineIntersection (const glm::vec2 &center, UnsignedFloat radius, const Line2D &line, glm::vec2 *solution1=nullptr, glm::vec2 *solution2=nullptr)
 
QSF_AI_API_EXPORT std::vector< glm::vec3 > calculatePartialCircleSupportPoints (const TurningConfiguration &turningConfig, const glm::vec3 &start, const glm::vec3 &goal, UnsignedFloat numSupportPointsPerWorldUnit=4.f)
 
QSF_AI_API_EXPORT boost::optional< CircleTangentConnectionResultcalculateTangentConnectionBetweenCircles (const SpatialConfiguration2D &start, const SpatialConfiguration2D &goal, UnsignedFloat turningRadius, bool maxHalfGoalCircle, bool allowShrinkingRadius, const PlanarProjector< float > &projector, const boost::optional< std::pair< Line2D, Line2D >> &corridor=boost::optional< std::pair< Line2D, Line2D >>())
 
QSF_AI_API_EXPORT boost::optional< SimpleTangentConnectionResultcalculateTangentConnection (const SpatialConfiguration2D &start, const glm::vec2 &goal, UnsignedFloat turningRadius, bool allowShrinkingRadius, const PlanarProjector< float > &projector, const boost::optional< std::pair< Line2D, Line2D >> &corridor=boost::optional< std::pair< Line2D, Line2D >>())
 
QSF_AI_API_EXPORT unsigned int calculateTangentPoints (const glm::vec2 &circleCenter, UnsignedFloat radius, const glm::vec2 &point, glm::vec2 &tp1, glm::vec2 &tp2, float epsilon=1e-6f)
 
void calculate2DExtents (const CollisionComponent &collision, UnsignedFloat &lateralExtent, UnsignedFloat &forwardExtent, UnsignedFloat &maxExtent)
 
float getRoughSizeOfCollisionComponent (const CollisionComponent &collisionComponent)
 
void QSF_AI_API_EXPORT disableLogic (Entity &entity)
 
void QSF_AI_API_EXPORT enableLogic (Entity &entity)
 
int ComputeBottomSurface (const glm::mat3x3 &rotation_, float minAbsUp_=0.0f)
 
ECollisionBoxMergeBoxes (const ECollisionBox *box1_, const ECollisionBox *box2_)
 
float ComputeMergedBoxVolume (const ECollisionBox *box1_, const ECollisionBox *box2_, glm::vec3 &extents, float &floorArea_)
 
int ConvexHull (const glm::vec3 *pts_, int n_, glm::vec3 *hull_)
 
float DistSegment2D (const glm::vec3 &a0_, const glm::vec3 &a1_, const glm::vec3 &b0_, const glm::vec3 &b1_)
 
bool InSegment (const glm::vec3 &p_, const glm::vec3 &s0_, const glm::vec3 &s1_)
 
bool IntersectSegments2D (const glm::vec3 &s00_, const glm::vec3 &s01_, const glm::vec3 &s10_, const glm::vec3 &s11_)
 
float ComputeDistanceToLineXYWithoutEndpoints (const glm::vec3 &point_, const glm::vec3 &p0_, const glm::vec3 &p1_)
 
void LocalToObjectState (EGenericObject *obj_, const ELocalMovementState &localState_, ERouterObjectState &objState_)
 
void MovePositionToFloor (glm::vec3 &position_, float fallheight=3.0f)
 
bool IsTargetBehind (const glm::vec3 &p0_, const glm::vec3 &p1_, const ERouterTarget *t_)
 
bool IsTargetBehind (const glm::vec3 &p0_, const glm::vec3 &p1_, const glm::vec3 &target_)
 
template<class T >
Interpolate (float alpha, const T &x0, const T &x1)
 
float AngleDifference (float a0_, float a1_)
 
float AngleBetweenVectors (const glm::vec3 &vector1, const glm::vec3 &vector2)
 
float GetSqrLen (const glm::vec3 &u_)
 
float dot (const glm::vec3 &u_, const glm::vec3 &v_)
 
float dot3 (const glm::vec3 &u_, const glm::vec3 &v_)
 
float perp (const glm::vec3 &u_, const glm::vec3 &v_)
 
glm::vec3 perp (const glm::vec3 &p_)
 
float IsLeft (const glm::vec3 &p0_, const glm::vec3 &p1_, const glm::vec3 &p2_)
 
bool ChangedMoveDir (const char &move0_, const char &move1_)
 
float DistancePointSegment (const glm::vec3 &p_, const glm::vec3 &s0_, const glm::vec3 &s1_)
 
glm::vec3 NearestPointOnSegment (const glm::vec3 &orig_, const glm::vec3 &segStart_, const glm::vec3 &segEnd_)
 
bool CheckDistance (const Bezier &curve_, const glm::vec3 &pos_, float maxDist_)
 
bool CheckDistance2D (const Bezier &curve_, const glm::vec3 &pos_, float maxDist_)
 
void ComputeBoundaries (glm::vec3 &minV_, glm::vec3 &maxV_, float size_)
 
float InterpolateDirection (float alpha, float x0, float x1)
 
void InflateTriangle (glm::vec3 &p0_, glm::vec3 &p1_, glm::vec3 &p2_, float inflateInUnits_)
 
float VectorToDirection (const glm::vec3 &dir_)
 
glm::vec3 DirectionToVector (float dir_)
 
void EulerYawRadToMatrix (float yaw_, glm::mat3x3 &matrix_)
 
void EulerYawToMatrix (float yaw_, glm::mat3x3 &matrix_)
 
float RotationMatrixToDirection (const glm::mat3x3 &rotMatrix_)
 
double GetGlobalTime ()
 
bool IntersectLines2DPoint (double start1x_, double start1y_, double end1x_, double end1y_, double start2x_, double start2y_, double end2x_, double end2y_, double &resultX, double &resultY)
 
bool IntersectLines2D (double start1x_, double start1y_, double end1x_, double end1y_, double start2x_, double start2y_, double end2x_, double end2y_, double &resultT, double &resultX, double &resultY)
 
void CreateRotationMatrixAroundAxis (float *matrix_, float xAxis_, float yAxis_, float zAxis_, float rad_)
 
float NormalizeEulerAngle (float Angle_)
 
float NormalizeRadAngle (float Angle_)
 
float Square (float X_)
 
float Log2 (float X_)
 
float Round (float X_)
 
int RoundToInt (float X_)
 
float Random01 ()
 Zufallszahl aus dem Intervall [0,1]. More...
 
float Random (float min_, float max_)
 
float Random0X1 ()
 Zufallszahl aus dem Intervall [0,1[. More...
 
float Random11 ()
 Zufallszahl aus dem Intervall [-1,+1]. More...
 
float Random1X1 ()
 Zufallszahl aus dem Intervall ]-1,+1[. More...
 
std::auto_ptr< PathSearchcreateCombinedPathSearch (unsigned int taskId, std::auto_ptr< PathSearchConfiguration > config)
 
bool tryReadObstructingDimensions (const Entity &entity, TemporaryObstacleData &data)
 
bool doesObstacleBlockPath (const glm::vec3 &startPos, const Path &path, const TurningConstraint &turningConstraint, const TemporaryObstacleData &obstacle)
 
path::AdaptionResult tryAdaptPathByMovingAroundTheOutlines (const glm::vec3 &startPos, NavigationComponent &navi, const NavigationComponentCollision &collision)
 
void extrudePath (Path &path, const TurningConstraint &turningConstraint, unsigned int minIndexToChange, unsigned int maxIndexToChange, Percentage idealLaneUsage, bool skipEvasionPoints)
 
path::AdaptionResult tryAdaptPathByMovingToTheSides (const glm::vec3 &startPos, NavigationComponent &navi, const NavigationComponentCollision &collision)
 
void correctWaypointHeights (Path &path, GroundMapQuery &heightQuery)
 
bool operator== (const Reservation &lhs, const Reservation &rhs)
 
GridCoordinates advanceInDirection (const GridCoordinates &pos, direction::TwoDimensional direction)
 
GridDelta operator- (const GridCoordinates &lhs, const GridCoordinates &rhs)
 
GridCoordinates operator+ (const GridCoordinates &lhs, const GridDelta &rhs)
 
bool operator< (const AreaConfiguration &lhs, const AreaConfiguration &rhs)
 
bool operator== (const AreaConfiguration &lhs, const AreaConfiguration &rhs)
 
bool operator!= (const AreaConfiguration &lhs, const AreaConfiguration &rhs)
 
QSF_AI_API_EXPORT void findClosestConfigurationsOnIdealLane (const glm::vec3 &pos, unsigned int mapId, unsigned int moverType, std::vector< SpatialConfiguration3D > &closestConfigs)
 
QSF_AI_API_EXPORT void findClosestConfigurationsOnOppositeDirectionIdealLanes (const SpatialConfiguration3D &currentConfig, unsigned int mapId, unsigned int moverType, std::vector< SpatialConfiguration3D > &bestConfigs)
 
move::Quality smoothIdealLaneWithCurves (const SearchContactPoint &start, const boost::optional< DynamicPortal > &startSupportPortal, std::deque< Waypoint > &waypoints, const boost::optional< DynamicPortal > &endSupportPortal, const PathSearchConfiguration &searchConfig, Path &path)
 
void smoothEvadeToTheSide (Path &path, const PathSearchConfiguration &searchConfig, unsigned int fromNodeIndex, unsigned int toNodeIndex, Percentage balanceFactor)
 
DynamicPortal toCirclePortal (const LaneNode3D &node)
 
bool tryCalculatePolygonPoints (const LaneNode3D &startNode, const LaneNode3D &endNode, glm::vec3 points[Lane::NUM_LANE_AREA_DEFINING_POINTS])
 
UnsignedFloat calculateFreeSpaceAtIdealLane (const LaneNode3D &startNode, const LaneNode3D &endNode, Percentage lineFactor)
 
UnsignedFloat calculateFreeSpaceAtIdealLane (const LaneNode3D &startNode, const LaneNode3D &endNode, const glm::vec3 &closePoint, float *laneDirectionFactor=nullptr)
 
bool isMovementAlongIdealLane (const LaneNode3D &laneStart, const LaneNode3D &laneEnd, const glm::vec3 &p1, const glm::vec3 &p2)
 
FunnelDistanceEstimationResult estimateFunnelSmoothedDistanceAlongLane (const glm::vec3 &start, const LaneNode3D *laneNodes, unsigned int firstIndex, unsigned int lastIndex, const glm::vec3 &goal)
 
float getHeightAlongLaneSegment (const LaneNode3D &start, const LaneNode3D &goal, float directionFactor)
 
bool isObstacleCompletelySeparated (const LaneNode3D *nodes, const ObstructingCollision &collision, const LaneBound &segmentBound, bool isUpperBound)
 
boost::optional< UnsignedFloatestimateManeuverToOrientationSteps (const TurningConstraint &constraint, const Radians &angle, UnsignedFloat freeSpace)
 
boost::optional< UnsignedFloatestimateManeuverToIdealLaneCosts (const TurningConstraint &constraint, const glm::vec3 &orientation3D, const glm::vec3 &towardsGoal3D, UnsignedFloat freeSpaceAvailable, bool mayMoveThroughIllegalArea)
 
QSF_AI_API_EXPORT move::Quality maneuverToIdealLane (const LaneNode3D &predecessor, const LaneNode3D &goal, const SpatialConfiguration3D &startConfig, const TurningConstraint &constraint, short movementOptions, unsigned int worldElementId, unsigned int maxManeuverSteps, Path &path)
 
QSF_AI_API_EXPORT bool maneuverToDesiredOrientation (const LaneNode3D &center, const glm::vec3 &startPosition, const glm::vec3 &startOrientation, const glm::vec3 &goalPosition, bool leaveForward, const TurningConstraint &constraint, unsigned int maxManeuverSteps, Path &solution)
 
void calculateIntersections (const TrafficLaneWorld &connectingWorld, const TrafficLaneWorld &connectedToWorld, std::deque< CombinedSearchConnectionPoint > &connections, std::vector< unsigned int > *limitedSelection=nullptr)
 
void calculateIntersections (const TrafficLaneWorld &navMap, std::deque< std::pair< unsigned int, unsigned int >> &intersections)
 
UnsignedFloat calculateFreeSpaceNeeded (const TurningConstraint &constraint, UnsignedFloat radius)
 
CurveTurningResult QSF_AI_API_EXPORT calculateTurningPointsForCurve2D (const glm::vec2 &start, const LaneNode2D &middle, const glm::vec2 &end, const TurningConstraint &turningConstraint, const PlanarProjector< float > &projector)
 
CurveTurningResult calculateTurningPointsForCurve3D (const glm::vec3 &curveStart3D, const LaneNode3D &curveMiddle3D, const glm::vec3 &curveEnd3D, const TurningConstraint &turningConstraint)
 
std::pair< EdgePortal, EdgePortalcalculateSegmentPortals (const glm::vec3 &curveStart3D, const LaneNode3D &curveMiddle3D, const glm::vec3 &curveEnd3D, const TurningConstraint &constraints)
 
move::Quality canLaneBeUsed (const LaneCollection &lanes, unsigned int laneIndex, const TurningConstraint &turningConstraint, CompoundDebugDrawRequest *drawBlockedParts=nullptr)
 
move::Quality canPartialLaneBeUsed (const LaneCollection &lanes, const SearchContactPoint &sep, unsigned int connectedNodeId, const TurningConstraint &turningConstraint, CompoundDebugDrawRequest *drawBlockedParts=nullptr)
 
move::Quality canPartialLaneBeUsed (const LaneCollection &lanes, unsigned int laneIndex, unsigned int firstNodeToTest, unsigned int lastNodeToTest, const TurningConstraint &turningConstraint, CompoundDebugDrawRequest *drawBlockedParts=nullptr)
 
move::Quality canTransitionBeUsed (const LaneCollection &lanes, unsigned int middleNodeId, const glm::vec3 &previousPositionOffset, unsigned int followingLaneId, const PathSearchConfiguration &searchConfig, UnsignedFloat *maneuverSpace=nullptr)
 
void calculateUsabilityForAllLanes (LaneCollection &lanes, const TurningConstraint &turningConstraint, unsigned int constraintIndex)
 
void calculateUsabilityForLane (LaneCollection &lanes, unsigned int laneId, const TurningConstraint &turningConstraint, unsigned int constraintIndex, CompoundDebugDrawRequest *debugDrawCollector=nullptr)
 
DynamicPortal writeNodesForPartialLane (const LaneCollection &lanes, const SearchContactPoint &searchEntryPoint, unsigned int connectedNodeId, bool towardsContactPoint, bool onPrimaryMap, bool movingForward, const PathSearchConfiguration &searchConfig, PathUnderConstruction &result)
 
std::pair< DynamicPortal, DynamicPortalwriteNodesForPartialLane (const LaneCollection &lanes, const SearchContactPoint &start, const SearchContactPoint &goal, bool onPrimaryMap, bool movingForward, const PathSearchConfiguration &searchConfig, PathUnderConstruction &result)
 
void writeAllNodesForLane (const LaneCollection &lanes, unsigned int laneIndex, unsigned int towardsNodeId, bool moveForward, bool onPrimaryMap, PathUnderConstruction &result)
 
QSF_AI_API_EXPORT void funnelSmoothing (const SpatialConfiguration3D &startConfig, unsigned int startArea, bool startsOnPrimaryMap, const TurningConstraint &constraints, bool mayReduceTurningCircle, std::deque< std::pair< Waypoint, EdgePortal >> &input, std::deque< Waypoint > &result, bool drawDebug=false)
 
QSF_AI_API_EXPORT void funnelSmoothing (const SearchContactPoint &startData, bool startsOnPrimaryMap, const PathSearchConfiguration &searchConfig, std::deque< std::pair< Waypoint, EdgePortal >> &input, std::deque< Waypoint > &result)
 

Variables

const int MAX_INT = 0x7fffffff
 
const int MIN_INT = ~MAX_INT
 

Typedef Documentation

typedef std::unordered_set<ECollisionObject*> qsf::ai::CollisionList

Definition at line 51 of file RouterObjectContainer.h.

Definition at line 48 of file RouterObjectContainer.h.

typedef std::unordered_map<int, ECollisionObject*> qsf::ai::CollisionObjectIdMap

Definition at line 50 of file RouterObjectContainer.h.

Definition at line 49 of file RouterObjectContainer.h.

typedef boost::optional<DebugParameters> qsf::ai::DebugSetting

Definition at line 42 of file DebugSetting.h.

Definition at line 51 of file routefindertypes.h.

Definition at line 42 of file routefindertypes.h.

Definition at line 58 of file routefindertypes.h.

typedef glm::tvec2<unsigned int, glm::defaultp> qsf::ai::GridCoordinates

Definition at line 25 of file GridCoordinates.h.

typedef glm::tvec2<int, glm::defaultp> qsf::ai::GridDelta

Definition at line 26 of file GridCoordinates.h.

typedef LaneNode<glm::vec2> qsf::ai::LaneNode2D

Definition at line 42 of file LaneNode-inl.h.

typedef LaneNode<glm::vec3> qsf::ai::LaneNode3D

Definition at line 41 of file LaneNode-inl.h.

Definition at line 22 of file PathUnderConstruction.h.

Definition at line 30 of file PerceptionEventQueue.h.

Definition at line 59 of file SpatialConfiguration.h.

Definition at line 60 of file SpatialConfiguration.h.

Definition at line 44 of file TurningRadiusCalculator.h.

Enumeration Type Documentation

Enumerator
EFPF_NONE 
EFPF_IGNORE_HYDRANTDISTANCE 
EFPF_NOCURVES 

Definition at line 30 of file FindPath.h.

Enumerator
EFP_INITIAL 
EFP_SEARCH_PATH 
EFP_SEARCH_FRONT_PATH 
EFP_SEARCH_BACK_PATH 
EFP_MOVE 
EFP_ABORT 
EFP_DONE 

Definition at line 19 of file FindPath.h.

Enumerator
EAT_UNKNOWN 
EAT_FLOOR 
EAT_OBJECT 
EAT_HOUSE 
EAT_VEHICLE 
EAT_PERSON 
EAT_LIQUID 
EAT_VIRTUAL 
EAT_ALL 
EATF_GENERICOBJECT 

Definition at line 47 of file EActor.h.

Enumerator
ECB_STATIC 
ECB_DYNAMIC 
ECB_DYNAMIC_MOVING 
ECB_VIRTUAL 

Definition at line 51 of file CollisionBox.h.

Enumerator
ERFCT_NONE 
ERFCT_MOVINGOBJECT 
ERFCT_STATICOBJECT 
ERFCT_POTENTIALMOVINGOBJECT 

Definition at line 44 of file routefindertypes.h.

Enumerator
EFP_NONE 
EFP_AXISALIGNED 
EFP_BOXALIGNED 
EFP_ALIGNED_CORNERS 
EFP_ALIGNED_SAMPLED 
EFP_PHYSICS 
EFP_CUSTOM_PLACEMENT 
EFP_ALIGNED_CORNERS_FLOOR 

Definition at line 67 of file EGenericObject.h.

Type definitions for different kinds of movement.

Enumerator
EMT_NONE 
EMT_FORWARD 
EMT_BACKWARD 
EMT_STRAIGHTSHUNTING 

Definition at line 41 of file RouterPath.h.

Enumerator
EOF_NONE 
EOF_PERSON_ENCLOSED 
EOF_LOCKED 
EOF_USABLE 
EOF_BULLDOZABLE 
EOF_TRANSPORTABLE 
EOF_PULLABLE 
EOF_ACCESSIBLE 
EOF_COOLABLE 
EOF_SHOOTABLE 
EOF_CUTABLE 
EOF_USABLE_WITH_MEGAPHONE 
EOF_RECOVERABLE 
EOF_FLOTSAM 
EOF_HIDDEN 
EOF_CARRYABLE_BY_BULLDOZER 
EOF_HAS_FIRE_EXTINGUISHER 
EOF_HAS_SHEARS 
EOF_HAS_CHAINSAW 
EOF_HAS_HOSE 
EOF_HAS_JUMPPAD 
EOF_HAS_ROADBLOCK 
EOF_HAS_FLASHGRENADE 
EOF_HAS_FIREAXE 
EOF_EMERGENCY 
EOF_ININACCESSIBLEAREA 
EOF_BLOCKED 

Definition at line 35 of file EGenericObject.h.

Enumerator
EOTC_ANYTHING 
EOTC_CAR 
EOTC_TRUCK 
EOTC_OFFROAD 
EOTC_TRACKVEHICLE 
EOTC_BOAT 
EOTC_SHIP 
EOTC_DIVER 
EOTC_AIRPLANE 
EOTC_CIVILIAN 
EOTC_SQUAD 
EOTC_SQUADCAR 
EOTC_HELILANDING 
EOTC_ANIMAL 
EOTC_VIRTUALFLOOR 
EOTC_TRAFFIC 
EOTC_SHOOTABLE 
EOTC_SEETHROUGH 
EOTC_FORCESTREET 
EOTC_RESCUEDOG 
_EOTC_NUMCLASSES 
EOTC_INVALID 

Definition at line 51 of file terrain.h.

Enumerator
EPR_UNKNOWN 
EPR_CIVILIAN 
EPR_SQUAD 
EPR_GANGSTER 
EPR_DROWNING 
EPR_ANIMAL 
EPR_PARAMEDIC 

Definition at line 29 of file EPerson.h.

Enumerator
EPO_CW 

clockwise

EPO_CCW 

counter clockwise

Definition at line 35 of file polygon.h.

Enumerator
ERF_NONE 
ERF_STATIC_OBJECTS 
ERF_IGNORE_MOVING_OBJECTS 
ERF_IGNORE_WATER 
ERF_IGNORE_CIVILIANS 
ERF_IS_LF 
ERF_ONLY_DIRECT_WAY 
ERF_NO_BACKWARDS 
ERF_NOCURVES 
ERF_IGNORE_CARRIER 
ERF_DONT_IGNORE_OWNER 
ERF_IGNORE_FOLLOWERS 
ERF_IGNORE_UNMOVED 
ERF_UNMOVED_NOSTATICFLAG 

Definition at line 19 of file routefindertypes.h.

Type definitions for computed paths of the route-finder.

Enumerator
RPT_NONE 
RPT_NORMAL 
RPT_BEZIER 

Definition at line 52 of file RouterPath.h.

Enumerator
ERSR_FAILED 
ERSR_FAILED_CANCELED 
ERSR_SUCCESS 
ERSR_SUCCESS_WITHLIMIT 
ERSR_COMPUTING 

Definition at line 52 of file RouterSearch.h.

Enumerator
ER_NO_SEARCH 
ER_LOCAL_SEARCH 

Definition at line 44 of file RouterSearch.h.

Enumerator
ERT_NONE 
ERT_POINT_TARGET 
ERT_POINT_DISTANCE_TARGET 
ERT_MULTI_POINT_TARGET 
ERT_OBJECT_TARGET 
ERT_TRACEABLE_OBJECT_TARGET 
_ERT_NUM_TARGET_TYPES 

Definition at line 43 of file RouterTarget.h.

Enumerator
RTLF_NONE 
RTLF_IGNORE_NONENEMY_UNITS 

Definition at line 53 of file routefindertypes.h.

Enumerator
ETM_NONE 
ETM_TURNTO 
ETM_TURNFROM 

Definition at line 54 of file RouterTarget.h.

Enumerator
ETP_ANY 
ETP_EQUIPMENTDOOR 
ETP_SHEARSDOOR 
ETP_SHEARSDOOR_OFFSET 
ETP_PASSENGERDOOR 
ETP_REARDOOR 
ETP_FIREHOSE_HOOKUP 
ETP_ENGINE 
ETP_EXTINGUISH 
ETP_EXTINGUISHHOSE 
ETP_ENGINE_EXTINGUISH 
ETP_AXE 
ETP_CHAINSAW 
ETP_ENTRANCEDOOR 
ETP_MEGAPHONE_DISTANCE 
ETP_DLK_BASKET 
ETP_LOADUP 
ETP_ENTRY_WINDOW_PARKING 
ETP_DLK_BASKET_BASE 
ETP_TREATMENT 
ETP_UNLOAD 
ETP_ENTRY_WINDOW 
ETP_INSTALL_FGRB 
ETP_SHOOT 
ETP_FOLLOW 
ETP_DLK_EXTINGUISH 
ETP_UNLOAD_TFMB 
ETP_FLAME_EFFECT 
ETP_FLAME_EFFECT_INACTIVE 
ETP_FLAME_EFFECT_INHOUSEFIRE 
ETP_CROSS_BRIDGE 
ETP_OPPOSITE_BRIDGE 
ETP_EXTINGUISH_PERSON 
ETP_TOUCHPERSON 
ETP_USE 
ETP_OBJECTSURFACE 
ETP_FREE_CONNECTOR 
ETP_RANDOM 
ETP_HOUSE_SAFE_DISTANCE 
ETP_PUTFOLLOWERINCAR 
ETP_MAX 

Definition at line 77 of file EActor.h.

Enumerator
EVR2_NOTASK 
EVR2_THW_FGRR_BKF 
EVR2_THW_FGRB_BLF 
EVR2_THW_FGRI_EKW 
EVR2_FIREFIGHTERS_ASF 
EVR2_FIREFIGHTERS_DEKONP 
EVR2_FIREFIGHTERS_DLK 
EVR2_FIREFIGHTERS_RW 
EVR2_FIREFIGHTERS_TLF 
EVR2_FIREFIGHTERS_LF 
EVR2_FIREFIGHTERS_FLB 
EVR2_FIREFIGHTERS_LPF 
EVR2_FIREFIGHTERS_FMB 
EVR2_FIREFIGHTERS_TFMB 
EVR2_POLICE_SW 
EVR2_POLICE_MTW 
EVR2_POLICE_PHC 
EVR2_POLICE_STW 
EVR2_POLICE_WAW 
EVR2_POLICE_GETAWAY 
EVR2_AMBULANCE_ITW 
EVR2_AMBULANCE_NEF 
EVR2_AMBULANCE_RHC 
EVR2_AMBULANCE_RHF 
EVR2_AMBULANCE_RTW 
EVR2_TAXI 
EVR2_BUS 
EVR2_DRIVERCAR 
EVR2_GANGSTER_GETAWAY 
EVR2_TV_HELI 
EVR2_FIREFIGHTERS_TLF_HISTORIC 
EVR2_THW_FGRR_RL 
EVR2_THW_FGRR_TRL 
EVR2_THW_FGRT_BH 
EVR2_FIREFIGHTERS_GTF 
EVR2_FIREFIGHTERS_LFKF 
EVR2_FIREFIGHTERS_LFKF_HELI 
EVR2_FIREFIGHTERS_LF_HELI 
EVR2_POLICE_GTW 
EVR2_POLICE_SEKHC 
EVR2_POLICE_SEKDF 
EVR2_POLICE_SEKD 
EVR2_AMBULANCE_TRANSEVAC 
EVR2_FIREFIGHTERS_FWDF 
EVR2_FIREFIGHTERS_FWD 
EVR2_ALL_SQUAD_VEHICLES 
EVR2_NUMTYPES 
_EVR2_NUMTYPES_EM2012 

Definition at line 22 of file EVehicleRoleInfo.h.

The PerceptionState describes which state the perception is in.

Enumerator
PERCEPTION_BEGAN 
PERCEPTION_CONTINUED 
PERCEPTION_ENDED 

Definition at line 35 of file Perception.h.

Enumerator
SIT_STRAIGHT 
SIT_CURVE 
SIT_SHUNTING 
SIT_STRAIGHTSHUNTING 

Definition at line 392 of file RouterLocalSearch.h.

Function Documentation

GridCoordinates qsf::ai::advanceInDirection ( const GridCoordinates pos,
direction::TwoDimensional  direction 
)
inline

Definition at line 24 of file GridCoordinates-inl.h.

float qsf::ai::AngleBetweenVectors ( const glm::vec3 &  vector1,
const glm::vec3 &  vector2 
)
inline

Definition at line 105 of file RouterHelper.h.

float qsf::ai::AngleDifference ( float  a0_,
float  a1_ 
)
inline

Definition at line 93 of file RouterHelper.h.

void qsf::ai::calculate2DExtents ( const CollisionComponent collision,
UnsignedFloat lateralExtent,
UnsignedFloat forwardExtent,
UnsignedFloat maxExtent 
)

Helpers function for converting the data from collision components to the format we need to use it in the AI. Calculates extents in several directions and writes the result to the reference parameters. Forward and Lateral extent are measured as distance to the midpoint on one dimension in the movement plane. The max extent is the worst distance in the movement plane that is relevant for example when rotating in place.

QSF_AI_API_EXPORT Radians qsf::ai::calculateAngleInDirection ( const glm::vec2 &  firstPoint,
const glm::vec2 &  secondPoint,
bool  clockwise,
const PlanarProjector< float > &  projector 
)

Calculates the angle between two vectors in a given direction (cw or ccw). The values have to be in coordinates local to the turning midpoint. The result is always positive.

QSF_AI_API_EXPORT unsigned int qsf::ai::calculateCircleCircleIntersection ( const glm::vec2 &  center1,
UnsignedFloat  radius1,
const glm::vec2 &  center2,
UnsignedFloat  radius2,
glm::vec2 *  intersection1 = nullptr,
glm::vec2 *  intersection2 = nullptr,
UnsignedFloat  epsilon = 1e-4f 
)
QSF_AI_API_EXPORT unsigned int qsf::ai::calculateCircleLineIntersection ( const glm::vec2 &  center,
UnsignedFloat  radius,
const Line2D line,
glm::vec2 *  solution1 = nullptr,
glm::vec2 *  solution2 = nullptr 
)
QSF_AI_API_EXPORT unsigned int qsf::ai::calculateCircleLineIntersectionAsDirectionFactor ( const glm::vec2 &  center,
UnsignedFloat  radius,
const Line2D line,
float *  directionFactorSolution1 = nullptr,
float *  directionFactorSolution2 = nullptr 
)
UnsignedFloat qsf::ai::calculateFreeSpaceAtIdealLane ( const LaneNode3D startNode,
const LaneNode3D endNode,
Percentage  lineFactor 
)
UnsignedFloat qsf::ai::calculateFreeSpaceAtIdealLane ( const LaneNode3D startNode,
const LaneNode3D endNode,
const glm::vec3 &  closePoint,
float *  laneDirectionFactor = nullptr 
)
UnsignedFloat qsf::ai::calculateFreeSpaceNeeded ( const TurningConstraint constraint,
UnsignedFloat  radius 
)

Calculate the actual free space needed when taking a turn with the given radius and turning constraint at the outer side of the curve. This scales between lateral and max free space needed depending on the maximum translation when using the curve.

template<typename Action >
void qsf::ai::calculateIntersectedCells ( glm::vec2  lineStart,
glm::vec2  lineEnd,
const GridConfiguration gridConfig,
Action action,
UnsignedFloat  snapVertexDelta = UncheckedUnsignedFloat(1e-2f) 
)

Calculate the indices of intersected cells when going from lineStart to lineEnd in a grid defined by the grid configuration. The passed action is called for each entered segment and needs to provide the GridCellFunctor interface defined above. The snap delta determines a range when a diagonal step is taken instead of intersecting very close to the edge. This is necessary because due to round off errors, the edge is otherwise never exactly hit.

Definition at line 142 of file Bresenham-inl.h.

template<typename Action >
void qsf::ai::calculateIntersectedCells ( const GridCoordinates startIndices,
const GridCoordinates goalIndices,
Action action,
UnsignedFloat  snapVertexDelta 
)

Definition at line 169 of file Bresenham-inl.h.

void qsf::ai::calculateIntersections ( const TrafficLaneWorld connectingWorld,
const TrafficLaneWorld connectedToWorld,
std::deque< CombinedSearchConnectionPoint > &  connections,
std::vector< unsigned int > *  limitedSelection = nullptr 
)

Calculates intersections between two traffic lane worlds Writes the result as a list of CombinedSearchConnectionPoints. May optionally be limited to test only some lanes by passing a reference parameter.

void qsf::ai::calculateIntersections ( const TrafficLaneWorld navMap,
std::deque< std::pair< unsigned int, unsigned int >> &  intersections 
)

Calculates the intersections between the lanes of one map. Writes the result as a list of pairs of area ids that are intersecting.

QSF_AI_API_EXPORT UnsignedFloat qsf::ai::calculateLengthOnCircle ( const glm::vec2 &  firstPoint,
const glm::vec2 &  secondPoint,
bool  clockwise,
const PlanarProjector< float > &  projector,
boost::optional< UnsignedFloat radius = boost::optional< UnsignedFloat >() 
)

Calculates the length along the outline of a circle. Input is two points in local coordinates to the circle center, a boolean whether we move around the circle clockwise or counter clockwise and optionally a radius if available. Otherwise the radius is calculated. The two points are ordered so we calculate from the first to the second. Be aware that all calculations are done in 2D, 3D coordinates are projected onto the ground plane and slope on the height axis is ignored.

QSF_AI_API_EXPORT std::vector<glm::vec3> qsf::ai::calculatePartialCircleSupportPoints ( const TurningConfiguration turningConfig,
const glm::vec3 &  start,
const glm::vec3 &  goal,
UnsignedFloat  numSupportPointsPerWorldUnit = 4.f 
)

Calculate support points on a circle segment between the two tangent points passed. Each point is defined by a position and a direction. The outline is approximated by a number of linear line segments. The additional parameter numSupportPointsPerWorldUnit lets you tweak the resolution of this approximation. It defines how many points are per world units of linear distance between points p1 and p2. Inherently assumes that the circle lies primarily in the ground plane and contains a projection to 2D. Always contains p1 and p2 as first and last points in the result. Forward defines whether to follow the direction given by the start and end orientations or in the opposite direction.

template<typename Vector >
UnsignedFloat qsf::ai::calculateRadiusOfCircle ( const Vector &  tangentPosition,
const Vector &  tangentDirection,
const Vector &  secondTangentPosition 
)

Definition at line 21 of file CircleMath-inl.h.

std::pair<EdgePortal, EdgePortal> qsf::ai::calculateSegmentPortals ( const glm::vec3 &  curveStart3D,
const LaneNode3D curveMiddle3D,
const glm::vec3 &  curveEnd3D,
const TurningConstraint constraints 
)

Calculate the portal data for a turning configuration. The portals are currently not optimized for the upcoming funnel algorithm but remain a roughly correct sketch. The first portal is the ending portal for the part from start to middle while the second portal is the beginning portal for the part from middle to end.

QSF_AI_API_EXPORT boost::optional<SimpleTangentConnectionResult> qsf::ai::calculateTangentConnection ( const SpatialConfiguration2D start,
const glm::vec2 &  goal,
UnsignedFloat  turningRadius,
bool  allowShrinkingRadius,
const PlanarProjector< float > &  projector,
const boost::optional< std::pair< Line2D, Line2D >> &  corridor = boost::optional< std::pair< Line2DLine2D >>() 
)

Calculate the tangent connection from the start configuration to the goal. Variant of the above function where there is no specific orientation required in the goal.

QSF_AI_API_EXPORT boost::optional<CircleTangentConnectionResult> qsf::ai::calculateTangentConnectionBetweenCircles ( const SpatialConfiguration2D start,
const SpatialConfiguration2D goal,
UnsignedFloat  turningRadius,
bool  maxHalfGoalCircle,
bool  allowShrinkingRadius,
const PlanarProjector< float > &  projector,
const boost::optional< std::pair< Line2D, Line2D >> &  corridor = boost::optional< std::pair< Line2DLine2D >>() 
)

Calculate the tangent connection between two circles defined by a start and an end spatial configuration. Both are expected to be on a circle with the defined common radius and we calculate a connection between the two circles that goes straight from one circle to the other. See http://www.gamasutra.com/view/feature/131505/toward_more_realistic_pathfinding.php?page=4 for the problem motivation. It considers moving forward or backward around both circles. The specific flag maxHalfGoalCircle disallows options where we move more than 50 % along the goal circle. The reasoning is that we move in front of the goal location in these cases and this is not desirable in our primary use case. The flag allowShrinkingRadius defines whether options that fail because of the radius are ignored or are investigated with a lowered radius. As an additional constraint we may provide a pair of lines which define a corridor that should not be left during planning.

glm::vec2 qsf::ai::calculateTangentDirection ( const glm::vec2 &  pointOnCircle,
const glm::vec2 &  midPoint,
bool  clockwiseTurn,
const PlanarProjector< float > &  projector 
)
QSF_AI_API_EXPORT glm::vec2 qsf::ai::calculateTangentPointOnCircle ( const glm::vec2 &  midPoint,
UnsignedFloat  radius,
const glm::vec2 &  desiredDirection,
bool  clockwiseRotation,
const PlanarProjector< float > &  projector 
)
QSF_AI_API_EXPORT unsigned int qsf::ai::calculateTangentPoints ( const glm::vec2 &  circleCenter,
UnsignedFloat  radius,
const glm::vec2 &  point,
glm::vec2 &  tp1,
glm::vec2 &  tp2,
float  epsilon = 1e-6f 
)

calculate the tangent points of lines going through point and being tangents to the circle defined by midpoint and radius. Returns the number of solutions written, either 0, 1 or 2. In case there are one or two solutions, the tp1 and tp2 reference variables are written. Zero solutions means the point is inside the circle. One solution is returned if the point is on the circle or the radius is zero. The epsilon is used as a margin for distance when the point snaps onto the circle.

std::pair<glm::vec2, glm::vec2> qsf::ai::calculateTangentPointsOnCircle ( const glm::vec2 &  midPoint,
UnsignedFloat  radius,
const glm::vec2 &  tangentDirection 
)
CurveTurningResult QSF_AI_API_EXPORT qsf::ai::calculateTurningPointsForCurve2D ( const glm::vec2 &  start,
const LaneNode2D middle,
const glm::vec2 &  end,
const TurningConstraint turningConstraint,
const PlanarProjector< float > &  projector 
)

Determines whether a single curve defined by three consecutive lane nodes in 2D can be used by some entity with the given movement restriction The bool allowReducingTheTurningRadius defines whether the turning radius is a hard or soft constraint. In the latter case, it may actually create results that don't pay attention to the radius if there is no such solution.

CurveTurningResult qsf::ai::calculateTurningPointsForCurve3D ( const glm::vec3 &  curveStart3D,
const LaneNode3D curveMiddle3D,
const glm::vec3 &  curveEnd3D,
const TurningConstraint turningConstraint 
)

3D variant of calculation for a single curve.

void qsf::ai::calculateUsabilityForAllLanes ( LaneCollection lanes,
const TurningConstraint turningConstraint,
unsigned int  constraintIndex 
)

Tests the lanes(s) passed whether these can be used by an entity with the given the turning restriction. Stores the result with the given constraint index.

void qsf::ai::calculateUsabilityForLane ( LaneCollection lanes,
unsigned int  laneId,
const TurningConstraint turningConstraint,
unsigned int  constraintIndex,
CompoundDebugDrawRequest debugDrawCollector = nullptr 
)
move::Quality qsf::ai::canLaneBeUsed ( const LaneCollection lanes,
unsigned int  laneIndex,
const TurningConstraint turningConstraint,
CompoundDebugDrawRequest drawBlockedParts = nullptr 
)

Tests whether a single lane can be used by an entity with the given the turning restriction. Tests all the inter segment transitions in succession.

move::Quality qsf::ai::canPartialLaneBeUsed ( const LaneCollection lanes,
const SearchContactPoint sep,
unsigned int  connectedNodeId,
const TurningConstraint turningConstraint,
CompoundDebugDrawRequest drawBlockedParts = nullptr 
)

Tests whether a partial single lane can be used. Variant of the canLaneBeUsed call that allows testing only a partial lane. The part to be used is defined by the id of an entered segment and a boolean flag for the direction in which we follow the lane. This has nothing to do with the orientation of the entity.

move::Quality qsf::ai::canPartialLaneBeUsed ( const LaneCollection lanes,
unsigned int  laneIndex,
unsigned int  firstNodeToTest,
unsigned int  lastNodeToTest,
const TurningConstraint turningConstraint,
CompoundDebugDrawRequest drawBlockedParts = nullptr 
)
move::Quality qsf::ai::canTransitionBeUsed ( const LaneCollection lanes,
unsigned int  middleNodeId,
const glm::vec3 &  previousPositionOffset,
unsigned int  followingLaneId,
const PathSearchConfiguration searchConfig,
UnsignedFloat maneuverSpace = nullptr 
)

Tests whether a single transition between two lane ends can be used by some entity with the given movement restriction. The previous position is passed as relative offset from the node position. The optional output maneuver space is written independent of the return value if it is provided at all.

bool qsf::ai::ChangedMoveDir ( const char &  move0_,
const char &  move1_ 
)
inline

Definition at line 167 of file RouterHelper.h.

bool qsf::ai::CheckDistance ( const Bezier curve_,
const glm::vec3 &  pos_,
float  maxDist_ 
)
inline

Definition at line 214 of file RouterHelper.h.

bool qsf::ai::CheckDistance2D ( const Bezier curve_,
const glm::vec3 &  pos_,
float  maxDist_ 
)
inline

Definition at line 230 of file RouterHelper.h.

int qsf::ai::ComputeBottomSurface ( const glm::mat3x3 &  rotation_,
float  minAbsUp_ = 0.0f 
)
void qsf::ai::ComputeBoundaries ( glm::vec3 &  minV_,
glm::vec3 &  maxV_,
float  size_ 
)
inline

Definition at line 252 of file RouterHelper.h.

float qsf::ai::ComputeDistanceToLineXYWithoutEndpoints ( const glm::vec3 &  point_,
const glm::vec3 &  p0_,
const glm::vec3 &  p1_ 
)
float qsf::ai::ComputeMergedBoxVolume ( const ECollisionBox box1_,
const ECollisionBox box2_,
glm::vec3 &  extents,
float &  floorArea_ 
)
int qsf::ai::ConvexHull ( const glm::vec3 *  pts_,
int  n_,
glm::vec3 *  hull_ 
)
void qsf::ai::correctWaypointHeights ( Path path,
GroundMapQuery heightQuery 
)
std::auto_ptr<PathSearch> qsf::ai::createCombinedPathSearch ( unsigned int  taskId,
std::auto_ptr< PathSearchConfiguration config 
)
void qsf::ai::CreateRotationMatrixAroundAxis ( float *  matrix_,
float  xAxis_,
float  yAxis_,
float  zAxis_,
float  rad_ 
)
inline
glm::vec3 qsf::ai::DirectionToVector ( float  dir_)
inline

Definition at line 294 of file RouterHelper.h.

void QSF_AI_API_EXPORT qsf::ai::disableLogic ( Entity entity)
float qsf::ai::DistancePointSegment ( const glm::vec3 &  p_,
const glm::vec3 &  s0_,
const glm::vec3 &  s1_ 
)
inline

Definition at line 173 of file RouterHelper.h.

float qsf::ai::distanceToConvexPolygon ( const glm::vec2 &  point,
const glm::vec2 *  polygonFirst,
const glm::vec2 *  polygonLast 
)
float qsf::ai::DistSegment2D ( const glm::vec3 &  a0_,
const glm::vec3 &  a1_,
const glm::vec3 &  b0_,
const glm::vec3 &  b1_ 
)
bool qsf::ai::doesObstacleBlockPath ( const glm::vec3 &  startPos,
const Path path,
const TurningConstraint turningConstraint,
const TemporaryObstacleData obstacle 
)
float qsf::ai::dot ( const glm::vec3 &  u_,
const glm::vec3 &  v_ 
)
inline

Definition at line 117 of file RouterHelper.h.

float qsf::ai::dot3 ( const glm::vec3 &  u_,
const glm::vec3 &  v_ 
)
inline

Definition at line 123 of file RouterHelper.h.

void QSF_AI_API_EXPORT qsf::ai::enableLogic ( Entity entity)
FunnelDistanceEstimationResult qsf::ai::estimateFunnelSmoothedDistanceAlongLane ( const glm::vec3 &  start,
const LaneNode3D laneNodes,
unsigned int  firstIndex,
unsigned int  lastIndex,
const glm::vec3 &  goal 
)

Estimate the distance traveled along the laneNodes in the array given that we ultimately want to reach goal from start. It roughly estimates what an ideal funnel smoothing would but as it it used inside the AStar as estimation function for a lot of nodes it needs to be much quicker than the regular algorithm. It is therefore by design a very simple algorithm mimicking the funnel smoothing idea. The nodes to use are defined by the interval [firstIndex, lastIndex] in the laneNodes array. The direction is defined by whether endIndex is smaller or greater than beginIndex.

boost::optional<UnsignedFloat> qsf::ai::estimateManeuverToIdealLaneCosts ( const TurningConstraint constraint,
const glm::vec3 &  orientation3D,
const glm::vec3 &  towardsGoal3D,
UnsignedFloat  freeSpaceAvailable,
bool  mayMoveThroughIllegalArea 
)

Estimate the costs it takes to maneuver onto the ideal lane. Returns an uninitialized value if the setting indicates we can't maneuver at all. Does not contain cost factor for the pure distance to move, only the maneuvering overhead itself.

boost::optional<UnsignedFloat> qsf::ai::estimateManeuverToOrientationSteps ( const TurningConstraint constraint,
const Radians angle,
UnsignedFloat  freeSpace 
)

Function to estimate the steps for maneuvering to a desired orientation. Parameters are the angle to change and the available free space and the turning constraint. Returns an uninitialized value if the free space is too small to allow maneuvering at all.

void qsf::ai::EulerYawRadToMatrix ( float  yaw_,
glm::mat3x3 &  matrix_ 
)
inline

Definition at line 299 of file RouterHelper.h.

void qsf::ai::EulerYawToMatrix ( float  yaw_,
glm::mat3x3 &  matrix_ 
)
inline

Definition at line 311 of file RouterHelper.h.

void qsf::ai::extrudePath ( Path path,
const TurningConstraint turningConstraint,
unsigned int  minIndexToChange,
unsigned int  maxIndexToChange,
Percentage  idealLaneUsage,
bool  skipEvasionPoints 
)
QSF_AI_API_EXPORT void qsf::ai::findClosestConfigurationsOnIdealLane ( const glm::vec3 &  pos,
unsigned int  mapId,
unsigned int  moverType,
std::vector< SpatialConfiguration3D > &  closestConfigs 
)

Find combinations of position on ideal lane & direction of the lane that are closest to the given position and fitting to the user type.

QSF_AI_API_EXPORT void qsf::ai::findClosestConfigurationsOnOppositeDirectionIdealLanes ( const SpatialConfiguration3D currentConfig,
unsigned int  mapId,
unsigned int  moverType,
std::vector< SpatialConfiguration3D > &  bestConfigs 
)

Find combinations of position on ideal & direction that are close and in opposite direction to the current facing.

QSF_AI_API_EXPORT void qsf::ai::funnelSmoothing ( const SpatialConfiguration3D startConfig,
unsigned int  startArea,
bool  startsOnPrimaryMap,
const TurningConstraint constraints,
bool  mayReduceTurningCircle,
std::deque< std::pair< Waypoint, EdgePortal >> &  input,
std::deque< Waypoint > &  result,
bool  drawDebug = false 
)

Create a smooth path that starts in the start config, moves successively through the input and ends up at the final position in input. Writes the result parameter. The core idea of the funnel is to create a shortest path inside a halfway calculated path in the form of connected world areas. It tries to create a minimal distance path with as few turns as possible. See http://digestingduck.blogspot.de/2010/03/simple-stupid-funnel-algorithm.html for the core idea. Our version is enhanced in several ways in that we need to pay attention to turning radius. The input parameter is also changed in that an edge ordering is done as a preliminary step on the input data.

QSF_AI_API_EXPORT void qsf::ai::funnelSmoothing ( const SearchContactPoint startData,
bool  startsOnPrimaryMap,
const PathSearchConfiguration searchConfig,
std::deque< std::pair< Waypoint, EdgePortal >> &  input,
std::deque< Waypoint > &  result 
)
double qsf::ai::GetGlobalTime ( )
float qsf::ai::getHeightAlongLaneSegment ( const LaneNode3D start,
const LaneNode3D goal,
float  directionFactor 
)

Retrieves the height value by linearly interpolating along the lane.

float qsf::ai::getRoughSizeOfCollisionComponent ( const CollisionComponent collisionComponent)

Helper function to calculate the rough XZ size of a collision component for use with the AI sensor perception system. It's rather cheap and simply returns a very rough number to decide wether a collider is pretty small or pretty large.

float qsf::ai::GetSqrLen ( const glm::vec3 &  u_)
inline

Definition at line 111 of file RouterHelper.h.

void qsf::ai::InflateTriangle ( glm::vec3 &  p0_,
glm::vec3 &  p1_,
glm::vec3 &  p2_,
float  inflateInUnits_ 
)
bool qsf::ai::InSegment ( const glm::vec3 &  p_,
const glm::vec3 &  s0_,
const glm::vec3 &  s1_ 
)
template<class T >
T qsf::ai::Interpolate ( float  alpha,
const T &  x0,
const T &  x1 
)
inline

Definition at line 85 of file RouterHelper.h.

float qsf::ai::InterpolateDirection ( float  alpha,
float  x0,
float  x1 
)
inline

Definition at line 263 of file RouterHelper.h.

bool qsf::ai::IntersectLines2D ( double  start1x_,
double  start1y_,
double  end1x_,
double  end1y_,
double  start2x_,
double  start2y_,
double  end2x_,
double  end2y_,
double &  resultT,
double &  resultX,
double &  resultY 
)
bool qsf::ai::IntersectLines2DPoint ( double  start1x_,
double  start1y_,
double  end1x_,
double  end1y_,
double  start2x_,
double  start2y_,
double  end2x_,
double  end2y_,
double &  resultX,
double &  resultY 
)
bool qsf::ai::IntersectSegments2D ( const glm::vec3 &  s00_,
const glm::vec3 &  s01_,
const glm::vec3 &  s10_,
const glm::vec3 &  s11_ 
)
area::PointRelation qsf::ai::isInsideConvexPolygon ( const glm::vec2 &  point,
const glm::vec2 *  polygonFirst,
const glm::vec2 *  polygonLast 
)
float qsf::ai::IsLeft ( const glm::vec3 &  p0_,
const glm::vec3 &  p1_,
const glm::vec3 &  p2_ 
)
inline

returns > 0 if p0_, p1_, p2_ are oriented ccw, < 0 if they are oriented cw, = 0 if they are collinear.

Definition at line 143 of file RouterHelper.h.

bool qsf::ai::isMovementAlongIdealLane ( const LaneNode3D laneStart,
const LaneNode3D laneEnd,
const glm::vec3 &  p1,
const glm::vec3 &  p2 
)

Projects points p1 and p2 onto the line defined by start and goal. Returns whether the movement from the projected p1 to the projected p2 is along the lane (from start to goal) or not.

bool qsf::ai::isObstacleCompletelySeparated ( const LaneNode3D nodes,
const ObstructingCollision collision,
const LaneBound segmentBound,
bool  isUpperBound 
)

Tests whether an obstructing obstacle is completely in front / behind a reference point given the ideal lane. This is used for cases where we start and/or end inside this segment so we need to be clear which part of the segment is actually blocked. All points are projected onto the ideal lane for this decision. This is relevant for example to decide whether we need to take care of an obstacle or not. The flag isUpperBound determines whether the lane bound is an upper or lower bound.

bool qsf::ai::IsTargetBehind ( const glm::vec3 &  p0_,
const glm::vec3 &  p1_,
const ERouterTarget t_ 
)
bool qsf::ai::IsTargetBehind ( const glm::vec3 &  p0_,
const glm::vec3 &  p1_,
const glm::vec3 &  target_ 
)
void qsf::ai::LocalToObjectState ( EGenericObject obj_,
const ELocalMovementState localState_,
ERouterObjectState objState_ 
)
float qsf::ai::Log2 ( float  X_)
inline

Definition at line 42 of file mathtool.h.

QSF_AI_API_EXPORT bool qsf::ai::maneuverToDesiredOrientation ( const LaneNode3D center,
const glm::vec3 &  startPosition,
const glm::vec3 &  startOrientation,
const glm::vec3 &  goalPosition,
bool  leaveForward,
const TurningConstraint constraint,
unsigned int  maxManeuverSteps,
Path solution 
)

Try to maneuver in place to reach a desired orientation. The return value signals whether a solution was found and is equal to the solution optional being initialized inside the function.

QSF_AI_API_EXPORT move::Quality qsf::ai::maneuverToIdealLane ( const LaneNode3D predecessor,
const LaneNode3D goal,
const SpatialConfiguration3D startConfig,
const TurningConstraint constraint,
short  movementOptions,
unsigned int  worldElementId,
unsigned int  maxManeuverSteps,
Path path 
)

Function to find a way onto the ideal lane of a segment. We are moving to the goal node and the predecessor is the last node before that one. This defines the direction as well as the available space. The result is written into the path reference parameter. Returns the quality of the created path. For the movement options bitmask parameter see NavigationComponent::MovementFlags

ECollisionBox* qsf::ai::MergeBoxes ( const ECollisionBox box1_,
const ECollisionBox box2_ 
)
QSF_AI_API_EXPORT glm::vec2 qsf::ai::movePointOnCircle ( const glm::vec2 &  current,
const TurningConfiguration turningConfig,
UnsignedFloat  distance,
const PlanarProjector< float > &  projector 
)
void qsf::ai::MovePositionToFloor ( glm::vec3 &  position_,
float  fallheight = 3.0f 
)
glm::vec3 qsf::ai::NearestPointOnSegment ( const glm::vec3 &  orig_,
const glm::vec3 &  segStart_,
const glm::vec3 &  segEnd_ 
)
inline

Definition at line 191 of file RouterHelper.h.

float qsf::ai::NormalizeEulerAngle ( float  Angle_)
float qsf::ai::NormalizeRadAngle ( float  Angle_)
bool qsf::ai::operator!= ( const AreaConfiguration lhs,
const AreaConfiguration rhs 
)
inline

Definition at line 40 of file AreaConfiguration-inl.h.

GridCoordinates qsf::ai::operator+ ( const GridCoordinates lhs,
const GridDelta rhs 
)
inline

Definition at line 57 of file GridCoordinates-inl.h.

GridDelta qsf::ai::operator- ( const GridCoordinates lhs,
const GridCoordinates rhs 
)
inline

Definition at line 50 of file GridCoordinates-inl.h.

bool qsf::ai::operator< ( const AreaConfiguration lhs,
const AreaConfiguration rhs 
)
inline

Definition at line 30 of file AreaConfiguration-inl.h.

bool qsf::ai::operator== ( const Reservation lhs,
const Reservation rhs 
)
inline

Definition at line 19 of file Reservation-inl.h.

bool qsf::ai::operator== ( const AreaConfiguration lhs,
const AreaConfiguration rhs 
)
inline

Definition at line 35 of file AreaConfiguration-inl.h.

float qsf::ai::perp ( const glm::vec3 &  u_,
const glm::vec3 &  v_ 
)
inline

Definition at line 129 of file RouterHelper.h.

glm::vec3 qsf::ai::perp ( const glm::vec3 &  p_)
inline

Definition at line 135 of file RouterHelper.h.

float qsf::ai::Random ( float  min_,
float  max_ 
)
inline

Definition at line 65 of file mathtool.h.

float qsf::ai::Random01 ( )
inline

Zufallszahl aus dem Intervall [0,1].

Definition at line 60 of file mathtool.h.

float qsf::ai::Random0X1 ( )
inline

Zufallszahl aus dem Intervall [0,1[.

Definition at line 73 of file mathtool.h.

float qsf::ai::Random11 ( )
inline

Zufallszahl aus dem Intervall [-1,+1].

Definition at line 81 of file mathtool.h.

float qsf::ai::Random1X1 ( )
inline

Zufallszahl aus dem Intervall ]-1,+1[.

Definition at line 89 of file mathtool.h.

float qsf::ai::RotationMatrixToDirection ( const glm::mat3x3 &  rotMatrix_)
float qsf::ai::Round ( float  X_)
inline

Definition at line 47 of file mathtool.h.

int qsf::ai::RoundToInt ( float  X_)
inline

Definition at line 52 of file mathtool.h.

void qsf::ai::smoothEvadeToTheSide ( Path path,
const PathSearchConfiguration searchConfig,
unsigned int  fromNodeIndex,
unsigned int  toNodeIndex,
Percentage  balanceFactor 
)
move::Quality qsf::ai::smoothIdealLaneWithCurves ( const SearchContactPoint start,
const boost::optional< DynamicPortal > &  startSupportPortal,
std::deque< Waypoint > &  waypoints,
const boost::optional< DynamicPortal > &  endSupportPortal,
const PathSearchConfiguration searchConfig,
Path path 
)
float qsf::ai::Square ( float  X_)
inline

Definition at line 37 of file mathtool.h.

DynamicPortal qsf::ai::toCirclePortal ( const LaneNode3D node)
inline

Definition at line 45 of file LaneNode-inl.h.

path::AdaptionResult qsf::ai::tryAdaptPathByMovingAroundTheOutlines ( const glm::vec3 &  startPos,
NavigationComponent navi,
const NavigationComponentCollision collision 
)
path::AdaptionResult qsf::ai::tryAdaptPathByMovingToTheSides ( const glm::vec3 &  startPos,
NavigationComponent navi,
const NavigationComponentCollision collision 
)
bool qsf::ai::tryCalculatePolygonPoints ( const LaneNode3D startNode,
const LaneNode3D endNode,
glm::vec3  points[Lane::NUM_LANE_AREA_DEFINING_POINTS] 
)
bool qsf::ai::tryReadObstructingDimensions ( const Entity entity,
TemporaryObstacleData data 
)
float qsf::ai::VectorToDirection ( const glm::vec3 &  dir_)
inline

Computes the direction (angle in the xy-plane to the x-axis from the given direction vector.

Definition at line 286 of file RouterHelper.h.

void qsf::ai::writeAllNodesForLane ( const LaneCollection lanes,
unsigned int  laneIndex,
unsigned int  towardsNodeId,
bool  moveForward,
bool  onPrimaryMap,
PathUnderConstruction result 
)

Writes the temporary path nodes that define a lane into the reference parameter vector. Intermediate step of the smoothing algorithm that collects all nodes first. Used for collecting the nodes from the whole lanes that are crossed. The bool towards end defines in which direction we are moving along the lane - towards the end node or the start node. The id of the node we move towards determines in which direction we move along the lane. It needs to be one of the end nodes of the lane obviously. The bool onPrimaryMap is mainly needed to channel the information into the waypoints written.

DynamicPortal qsf::ai::writeNodesForPartialLane ( const LaneCollection lanes,
const SearchContactPoint searchEntryPoint,
unsigned int  connectedNodeId,
bool  towardsContactPoint,
bool  onPrimaryMap,
bool  movingForward,
const PathSearchConfiguration searchConfig,
PathUnderConstruction result 
)

Writes the gateways that define the part of a lane that is crossed when using the search entry point towards the connected node into the reference parameter vector. Intermediate step of the smoothing algorithm that collects all nodes first. Used for collecting the nodes from the start and finish parts. The bool towards contact point signals whether we are using the search entry point as starting or goal role. Returns the supporting portal which is the one just behind the first node written.

std::pair<DynamicPortal, DynamicPortal> qsf::ai::writeNodesForPartialLane ( const LaneCollection lanes,
const SearchContactPoint start,
const SearchContactPoint goal,
bool  onPrimaryMap,
bool  movingForward,
const PathSearchConfiguration searchConfig,
PathUnderConstruction result 
)

Variant of the above function that collects the nodes used in a case where neither lane node is actually reached. Both search entry points need to indicate the same lane for this function to work. Returns both supporting portals, first is the one on the start side while second is the one on the goal side.

Variable Documentation

const int qsf::ai::MAX_INT = 0x7fffffff

Definition at line 19 of file mathtool.h.

const int qsf::ai::MIN_INT = ~MAX_INT

Definition at line 20 of file mathtool.h.