Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

▼Ngrail
►Ndata
►Ngenerated
CBehaviorDataBuilder
CBlackboardStateBuilder
CEntityGroupDataBuilder
CEntityStateBuilder
CEvaluationDebugDataBuilder
CFLATBUFFERS_FINAL_CLASS
CGrailDebugInfoBuilder
CGrailStateSnapshotBuilder
CPlannerActionSnapshotBuilder
CPlannerIterationSnapshotBuilder
CPlannerReasonerSnapshotBuilder
CPlannerWorldObjectSnapshotBuilder
CSimulatedGameActionMetadataSnapshotBuilder
CSimulatedGameIterationSnapshotBuilder
CSimulatedGameMonteCarloEventSnapshotBuilder
CSimulatedGameReasonerSnapshotBuilder
CSimulatedGameUCTEventSnapshotBuilder
CSimulatedGameUnitSnapshotBuilder
CStringStringMapBuilder
CUintVectorOfStringMapBuilder
CUtilityEvaluatorSnapshotBuilder
CUtilityReasonerSnapshotBuilder
CBehaviorData
CBehaviorModel
CBlackboardState
CConsiderationModel
CCurveDataModel
CEntityBlackboardNamePair
CEntityGroupData
CEntityGroupModel
CEntityModel
CEntityNamePriorityPair
CEntityState
CEvaluationDebugData	debug data describing singular evaluator
CEvaluatorNodeModel
CEvaluatorToBehaviorAssignment
CEvaluatorTreeModel
CEvaluatorTreeReference
CGrailConfiguration
CGrailDebugInfo
CGrailStateSnapshot
CPlannerActionSnapshot
CPlannerIterationSnapshot
CPlannerReasonerSnapshot
CPlannerWorldObjectSnapshot
CSimulatedGameActionMetadataSnapshot
CSimulatedGameIterationSnapshot
CSimulatedGameMonteCarloEventSnapshot
CSimulatedGameReasonerSnapshot
CSimulatedGameUCTEventSnapshot
CSimulatedGameUnitSnapshot
CUtilityEvaluatorSnapshot	debug snapshot of whole evaluator tree assigned to evaluated object
CUtilityReasonerModel
CUtilityReasonerSnapshot
CUtilitySelectorModel
►Nevaluator
►Nhelpers
CIConsiderationProvider	IConsiderationProvider - Helper used for acquiring consideration instance, given its name loaded from config file
CAggregator	The Aggregator class - Base class for an Evaluator aggregating multiple other Evaluators' scores into one output
CAverageAggregator	The AverageAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by taking the average
CBezierSpline	The BezierSpline class -Composite Cubic Bezier Curve
CConsideration	The Consideration class - Abstract type of Evaluator representing a subset of game state
CConstantFunction	The ConstantFunction class - Constant function
CCurve	The Curve class - Defines objects transforming one value into the other
CDoubleSidedBound	The DoubleSidedBound class - Bounds output of provided Evaluator from both sides
CEvaluator	The Evaluator class - base class being able to evaluate given context and output the result
CExponentialFunction	The ExponentialFunction class - Exponential function
CLinearFunction	The LinearFunction class - Linear Function
CLinearlyInterpolatedCurve	The LinearlyInterpolatedCurve class -Curve consisting of multiple linear segments
CLowerBound	The LowerBound class - Lower-bounds output of provided Evaluator
CMaxAggregator	The MaxAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by taking the highest of those values
CMinAggregator	The MinAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by taking the lowest of those values
CPowerFunction	The PowerFunction class - Power function
CProductAggregator	The ProductAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by multiplying all those values
CSigmoidFunction	The SigmoidFunction class - Sigmoid function
CStaircaseFunction	The StaircaseFunction class - Function consisting of multiple discrete values
CStepData	The StepData struct - Helper structure describing discrete values used in Staircase function
CSumAggregator	The SumAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by summing up all those values
CUnitStepFunction	The UnitStepFunction class - Unit Step Function
CUpperBound	The UpperBound class - Upper-bounds output of provided Evaluator
►Nevolution
CBaseEvoParam	BaseEvoParam - A class that represents a parameter that is modifiable (optimizable) by evolutionary algorithms. Unless your parameter is only a positional index (represented by an integer from 0 to max), use a specialized version 'EvoParam<Type>'. These parameters form an encoding and are stored as member Fields or Properties in an 'Individual' and set as optimizable using 'Individual::SetMemberParameterOptimizable'. Typically, the 'Individual.SetMemberParameterOptimizable' function should be called in the constructor of an 'Individual'-derived class
CCrossover	The Crossover structure that encapsulates the crossover operation and its configuration in evolutionary algorithm
CEAOptimizer	A class that serves as the main interface for evolutionary algorithms in Grail
CEvoParam	EvoParam A class for defining evolutionary-optimizable parameters. They can be registered in Individuals for the evolutionary optimization functionality. The template type @T defines type of possible values the parameter may store. As T you have to either use a trivially destructible object or a smart pointer that will delete itself when it goes out of scope
CFitnessRepository	This class provides a functionality of assigning fitness values as averages from the previous evaluations. It can be used to minimize the effects of variance when fitness calculation is non-deterministic. Use 'AddSampleWithFitnessUpdate' method to store the current fitness and update it based on past evaluations
CIndividual	Represents an individual for evolutionary algorithms (EA). It stores the encoding consisting of optimizable parameters (represented by 'BaseEvoParam' and specialized 'EvoParam<Type>'. The members (fields or properties) should be registered for optimization using 'SetMemberParameterOptimizable' methods in your implementation of the constructor. In the optimization process, the EA will require assigning the fitness evaluation to the individual. Calculate it in your game environment based on the current values of Individual's parameters
CMutation	The Mutation structure that encapsulates the mutation operation and its configuration in evolutionary algorithm
CRouletteSampler	Provides a functionality of a fitness proportional roulette sampling of any objects that implement a GetFitness() method. In particular it is used by an evolutionary algorithm (EA). Because the implementation is optimized for usage in EA, the sampled elements are removed unless the method ends with 'WithReturn'
CSelection	Encapsulates the selection operation, i.e., how individuals are selected from the current population to the next generation, in evolutionary algorithm. See also EAOptimizer
►Nfsm
►CFiniteStateMachine	Class representing basic Finite State Machine
CTransition
CFiniteStateMachineBuilder	Builder for finite state machine
CFSMBehavior
CState	The FiniteStateMachineState class - Class representing state of finite state machine
►Nhelpers
CConfigInterpreter	used to construct entities and entity groups based on configuration data
CIReasonerFactory	responsible for producing reasoners, given their id
►Nlive
CCrc16
CLiveDebuggerServer
CLiveDebuggerServerBinary
CLiveDebuggerServerYaml
CTCPServer
CUDPServer
►Nlogger
CDefaultSink	sink writing messages to standard system output
CFileSink	sink writing messages to file
CLoggerManager
CSink	destination of logger messages
►Nplanner
CAction
CActionTemplate
CDomain
CDomainTranslator
CEmplacer
CEmplacer< const std::string >
CEmplacer< planner::TypedObjectParameter< std::string > >
CEmplacer< std::string >
CGoal
CGoalSelector
CIGoalAcceptor
CIPlannerObject	The interface to be implemented by classes that should be converted and bound to plan-space WorldObjects
CMemoryPool	preallocated memory container for optimization issues
CObjectIndexBinding
CObjectParameter
CParametrizedObject	The base class for parametrized objects (objects with parameters) used by the planning algorithm for state representation
►CPlanner
CAbstractPlan	Represents a formulated plan as a sequence of actions and a cost
CConfig	The Planner's run-time configuration parameters
►CPlannerReasoner	A reasoner which uses planners to find optimal sequences of behaviors based on goals
CConfig	The Planner's run-time configuration parameters
CPlannerReasonerSnapshotGenerator
CTypedObjectParameter
CWorldObject
CWorldObjectType
CWorldState
►Nsimgames
CEqualsForOfflineLearning	Helper that provides a EqualsForLearning() method. Used with ISimulatedGameAction only by OfflineLearning
CHashForOfflineLearning	Helper that provides a HashForLearning() method. Used with ISimulatedGameAction only by OfflineLearning
CISimulatedActionTranslator	Translates actions defined in SimulatedGame onto Behaviors used in Grail
CISimulatedGameAction	Base class for all actions in SimulatedGame. Derive from it for your actions
CISimulatedGameNodeObserver
CISimulatedGameStateTranslator
CISimulatedGameUnit	Base class of a unit in the SimulatedGame framework. A unit represents part of the game-state and peforms actions that affect the game-state. You should not create instances of this class. Use specializations @SimulatedGameThinkingUnit or @SimulatedGameStochasticUnit instead
CSimulatedGame	The main interface class for the SimulatedGame reasoner based on the MCTS algorithm. The class supports definition of a game, running simulations and obtaining results
CSimulatedGameActionMetadata	This class represents action defined in the SimulatedGames module with additional statistics (score, visits)
CSimulatedGameHelper
CSimulatedGameHeuristic	Interface that encapsulates an algorithm responsible for action-selection inside SimulatedGame (MCTS). This action-selection is performed in certain situations instead of sampling from the whole action space. The goal is to reduce the combinatorial complexity or just provide scripted behavior in certain moments of the game
CSimulatedGameNode	This class should not be visible to developers at all
CSimulatedGameReasoner
CSimulatedGameReasonerSnapshotGenerator
CSimulatedGameRuntime	An interface that is used to terminate simulation in MCTS and set scores to players. Scores are grabbed from here whenever a simulation ends. It is created automatically
CSimulatedGameSnapshotObserver
CSimulatedGameStochasticUnit	A base class of a unit in SimulatedGame that peforms actions according to some probability distribution. It does not represents any players in the game. It should be used if either (1) randomness affects actions available to other players (2) randomness heavily affects the game outcome. Random effects should be applied as actions of SimulatedGameStochasticUnit
CSimulatedGameThinkingUnit	A base class of a unit related to a rational/intelligent player. MCTS chooses actions for this kind of unit. See also SimulatedGameStochasticUnit. All units together represent the game state
►Nutility
►Nhelpers
CUtilityReasonerFactory	The UtilityReasonerConfigInterpreter class - A helper class used for creating Utility Reasoner instance using configuration data
►Nroulette_selector	The roulette selector namespace - contains method responsible for selecting most suitable objects based on roulette
CRouletteOptions	RouletteSelectionOptions - Struct determining options for roulette selection
CBlueprint	The Blueprint class - Responsible for producing contexts and instances of data used by UtilityReasoner
CBlueprintOption
CDefaultRandomNumberGenerator
CMaxUtilityReasoner
CRandomNumberGenerator
CRouletteUtilityReasoner
CSelectionOption	The SelectionOption struct - Helper structure describing one of the options being selected by Selector
CSelectionResult	The SelectionResult struct - Structure containing results of operations done by Selector
CUtilityReasoner	Class responsible for assigning behaviors using Utility System algorithm. All considered behaviors are given a score designating their utility in current situation. Most suitable behavior is chosen based on those scores
CUtilityReasonerSnapshotGenerator	Class responsible for generating snapshots of utility reasoner's state, which can be analyzed in Grail Tool
CAIEntity	Defines a basic object which can execute behaviors
CAIManager	Manages registered entities and shared blackboards
CBehavior	A high-level abstraction of actions in the game
CBehaviorSequence	specialized Behavior executing sequence of provided subbehaviors one by one
CBelongsToLibraryTypeGroup
CBelongsToLibraryTypeGroup< T, std::void_t< decltype(SerializeLibraryType(std::declval< T >()))> >
CBelongsToUserTypeGroup
CBelongsToUserTypeGroup< T, std::void_t< decltype(SerializeUserType(std::declval< T >()))> >
CBlackboard	grail's universal data container
CBlackboardEntry	The structure for holding elements in a Blackboard
CCanToString
CCanToString< T, std::void_t< decltype(std::to_string(std::declval< T >()))> >
CDebugInfoGenerator
CEntityEntry	EntityEntry - internal struct containing AIEntity and its relative priority. Entities with higher priority will be updated first
CEntityGroup
CEntityToken
►CGrailDebugger
CDebuggerData
CGrailStateSnapshotGenerator
CIDebugSnapshotReceiver
CIEntityChangeObserver
CIReasonerChangeObserver
CISnapshotGenerator
CIsPair
CIsPair< std::pair< T, U > >
CIsRawArray	SFINAE below - all sorts of helpers to determine types in runtime
CIsRawArray< T[]>
CIsRawArray< T[N]>
CIsSharedPointer
CIsTuple
CIsTuple< std::tuple< T... > >
CIsWeakPointer
CIsWeakPointer< std::weak_ptr< T > >
CITimestampProvider	Provides timestamps for debugging purposes, so debug data (e.g. events) can be placed on timeline
CPlan	A data structure used by PlannerReasoner to execute a sequence of behaviors
CReasoner	Entity's "brain", assigns them behaviors chosen by user-defined algorithms
CSnapshotGenerator
CSynchronizedEntityContainer
CTupleVisitor	Helpers to iterate over tuples (visitor pattern)
CTupleVisitor< 0 >