Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123]

Cgrail::planner::Planner::AbstractPlan	Represents a formulated plan as a sequence of actions and a cost
Cgrail::planner::Action
Cgrail::planner::ActionTemplate
Cgrail::AIEntity	Defines a basic object which can execute behaviors
Cgrail::AIManager	Manages registered entities and shared blackboards
►Cgrail::evolution::BaseEvoParam	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
Cgrail::evolution::EvoParam< T >	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
►Cgrail::Behavior	A high-level abstraction of actions in the game
Cgrail::BehaviorSequence	specialized Behavior executing sequence of provided subbehaviors one by one
Cgrail::fsm::FSMBehavior
Cgrail::data::BehaviorData
Cgrail::data::generated::BehaviorDataBuilder
Cgrail::data::BehaviorModel
Cgrail::Blackboard	grail's universal data container
Cgrail::BlackboardEntry	The structure for holding elements in a Blackboard
Cgrail::data::BlackboardState
Cgrail::data::generated::BlackboardStateBuilder
Cgrail::utility::Blueprint< InstanceType, ContexType, DataType >	The Blueprint class - Responsible for producing contexts and instances of data used by UtilityReasoner
Cgrail::utility::Blueprint< InstanceType, ContextType, DataType >
Cgrail::utility::BlueprintOption< InstanceType, ContextType, DataType >
Cgrail::planner::Planner::Config	The Planner's run-time configuration parameters
Cgrail::planner::PlannerReasoner::Config	The Planner's run-time configuration parameters
Cgrail::helpers::ConfigInterpreter	used to construct entities and entity groups based on configuration data
Cgrail::data::ConsiderationModel
Cgrail::live::Crc16
Cgrail::evolution::Crossover	The Crossover structure that encapsulates the crossover operation and its configuration in evolutionary algorithm
Cgrail::data::CurveDataModel
Cgrail::GrailDebugger::DebuggerData
Cgrail::planner::Domain
Cgrail::planner::DomainTranslator
Cgrail::evolution::EAOptimizer	A class that serves as the main interface for evolutionary algorithms in Grail
Cgrail::planner::Emplacer< T >
Cgrail::planner::Emplacer< const std::string >
Cgrail::planner::Emplacer< planner::TypedObjectParameter< std::string > >
Cgrail::planner::Emplacer< std::string >
Cgrail::data::EntityBlackboardNamePair
Cgrail::EntityEntry	EntityEntry - internal struct containing AIEntity and its relative priority. Entities with higher priority will be updated first
Cgrail::EntityGroup
Cgrail::data::EntityGroupData
Cgrail::data::generated::EntityGroupDataBuilder
Cgrail::data::EntityGroupModel
Cgrail::data::EntityModel
Cgrail::data::EntityNamePriorityPair
Cgrail::data::EntityState
Cgrail::data::generated::EntityStateBuilder
Cgrail::EntityToken
Cgrail::simgames::EqualsForOfflineLearning	Helper that provides a EqualsForLearning() method. Used with ISimulatedGameAction only by OfflineLearning
Cgrail::data::EvaluationDebugData	debug data describing singular evaluator
Cgrail::data::generated::EvaluationDebugDataBuilder
►Cgrail::evaluator::Evaluator< ContextType >	The Evaluator class - base class being able to evaluate given context and output the result
►Cgrail::evaluator::Aggregator< ContextType >	The Aggregator class - Base class for an Evaluator aggregating multiple other Evaluators' scores into one output
Cgrail::evaluator::AverageAggregator< ContextType >	The AverageAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by taking the average
Cgrail::evaluator::MaxAggregator< ContextType >	The MaxAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by taking the highest of those values
Cgrail::evaluator::MinAggregator< ContextType >	The MinAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by taking the lowest of those values
Cgrail::evaluator::ProductAggregator< ContextType >	The ProductAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by multiplying all those values
Cgrail::evaluator::SumAggregator< ContextType >	The SumAggregator class - Evaluator aggregating multiple other Evaluators' scores into one output by summing up all those values
Cgrail::evaluator::Consideration< ContextType >	The Consideration class - Abstract type of Evaluator representing a subset of game state
►Cgrail::evaluator::Curve< ContextType >	The Curve class - Defines objects transforming one value into the other
Cgrail::evaluator::BezierSpline< ContextType >	The BezierSpline class -Composite Cubic Bezier Curve
Cgrail::evaluator::ConstantFunction< ContextType >	The ConstantFunction class - Constant function
Cgrail::evaluator::DoubleSidedBound< ContextType >	The DoubleSidedBound class - Bounds output of provided Evaluator from both sides
Cgrail::evaluator::ExponentialFunction< ContextType >	The ExponentialFunction class - Exponential function
Cgrail::evaluator::LinearFunction< ContextType >	The LinearFunction class - Linear Function
Cgrail::evaluator::LinearlyInterpolatedCurve< ContextType >	The LinearlyInterpolatedCurve class -Curve consisting of multiple linear segments
Cgrail::evaluator::LowerBound< ContextType >	The LowerBound class - Lower-bounds output of provided Evaluator
Cgrail::evaluator::PowerFunction< ContextType >	The PowerFunction class - Power function
Cgrail::evaluator::SigmoidFunction< ContextType >	The SigmoidFunction class - Sigmoid function
Cgrail::evaluator::StaircaseFunction< ContextType >	The StaircaseFunction class - Function consisting of multiple discrete values
Cgrail::evaluator::UnitStepFunction< ContextType >	The UnitStepFunction class - Unit Step Function
Cgrail::evaluator::UpperBound< ContextType >	The UpperBound class - Upper-bounds output of provided Evaluator
Cgrail::data::EvaluatorNodeModel
Cgrail::data::EvaluatorToBehaviorAssignment
Cgrail::data::EvaluatorTreeModel
Cgrail::data::EvaluatorTreeReference
►Cfalse_type
Cgrail::BelongsToLibraryTypeGroup< T, typename >
Cgrail::BelongsToUserTypeGroup< T, typename >
Cgrail::CanToString< T, typename >
Cgrail::IsPair< typename >
Cgrail::IsRawArray< T >	SFINAE below - all sorts of helpers to determine types in runtime
Cgrail::IsSharedPointer< T >
Cgrail::IsTuple< typename >
Cgrail::IsWeakPointer< T >
Cgrail::fsm::FiniteStateMachineBuilder	Builder for finite state machine
Cgrail::evolution::FitnessRepository	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
Cgrail::planner::Goal
Cgrail::planner::GoalSelector
Cgrail::data::GrailConfiguration
Cgrail::data::GrailDebugInfo
Cgrail::data::generated::GrailDebugInfoBuilder
Cgrail::data::GrailStateSnapshot
Cgrail::data::generated::GrailStateSnapshotBuilder
Cgrail::simgames::HashForOfflineLearning	Helper that provides a HashForLearning() method. Used with ISimulatedGameAction only by OfflineLearning
Cgrail::evaluator::helpers::IConsiderationProvider< ContextType >	IConsiderationProvider - Helper used for acquiring consideration instance, given its name loaded from config file
►Cgrail::IDebugSnapshotReceiver
Cgrail::DebugInfoGenerator
►Cgrail::live::LiveDebuggerServer
Cgrail::live::LiveDebuggerServerBinary
Cgrail::live::LiveDebuggerServerYaml
►Cgrail::IEntityChangeObserver
Cgrail::GrailDebugger
►Cgrail::planner::IGoalAcceptor
Cgrail::planner::PlannerReasoner	A reasoner which uses planners to find optimal sequences of behaviors based on goals
Cgrail::evolution::Individual	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
Cgrail::planner::IPlannerObject	The interface to be implemented by classes that should be converted and bound to plan-space WorldObjects
►Cgrail::IReasonerChangeObserver
Cgrail::GrailDebugger
►Cgrail::helpers::IReasonerFactory	responsible for producing reasoners, given their id
Cgrail::utility::helpers::UtilityReasonerFactory	The UtilityReasonerConfigInterpreter class - A helper class used for creating Utility Reasoner instance using configuration data
Cgrail::simgames::ISimulatedActionTranslator	Translates actions defined in SimulatedGame onto Behaviors used in Grail
Cgrail::simgames::ISimulatedGameAction	Base class for all actions in SimulatedGame. Derive from it for your actions
Cgrail::simgames::ISimulatedGameNodeObserver
Cgrail::simgames::ISimulatedGameStateTranslator
►Cgrail::simgames::ISimulatedGameUnit	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
Cgrail::simgames::SimulatedGameStochasticUnit	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
Cgrail::simgames::SimulatedGameThinkingUnit	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
►Cgrail::ISnapshotGenerator
Cgrail::SnapshotGenerator< SnapshotType >
►Cgrail::SnapshotGenerator< data::GrailStateSnapshot >
Cgrail::GrailStateSnapshotGenerator
►Cgrail::SnapshotGenerator< data::PlannerReasonerSnapshot >
Cgrail::planner::PlannerReasonerSnapshotGenerator
►Cgrail::SnapshotGenerator< data::SimulatedGameReasonerSnapshot >
Cgrail::simgames::SimulatedGameReasonerSnapshotGenerator
►Cgrail::SnapshotGenerator< data::UtilityReasonerSnapshot >
Cgrail::utility::UtilityReasonerSnapshotGenerator	Class responsible for generating snapshots of utility reasoner's state, which can be analyzed in Grail Tool
Cgrail::ITimestampProvider	Provides timestamps for debugging purposes, so debug data (e.g. events) can be placed on timeline
Cgrail::logger::LoggerManager
Cgrail::planner::MemoryPool	preallocated memory container for optimization issues
Cgrail::evolution::Mutation	The Mutation structure that encapsulates the mutation operation and its configuration in evolutionary algorithm
Cgrail::planner::ObjectIndexBinding
►Cgrail::planner::ObjectParameter
Cgrail::planner::TypedObjectParameter< ParameterType >
►Cgrail::planner::ParametrizedObject	The base class for parametrized objects (objects with parameters) used by the planning algorithm for state representation
Cgrail::planner::WorldObject
Cgrail::planner::WorldObjectType
Cgrail::planner::WorldState
Cgrail::Plan	A data structure used by PlannerReasoner to execute a sequence of behaviors
Cgrail::planner::Planner
Cgrail::data::PlannerActionSnapshot
Cgrail::data::generated::PlannerActionSnapshotBuilder
Cgrail::data::PlannerIterationSnapshot
Cgrail::data::generated::PlannerIterationSnapshotBuilder
Cgrail::data::PlannerReasonerSnapshot
Cgrail::data::generated::PlannerReasonerSnapshotBuilder
Cgrail::data::PlannerWorldObjectSnapshot
Cgrail::data::generated::PlannerWorldObjectSnapshotBuilder
►Cgrail::utility::RandomNumberGenerator
Cgrail::utility::DefaultRandomNumberGenerator
►Cgrail::Reasoner	Entity's "brain", assigns them behaviors chosen by user-defined algorithms
Cgrail::planner::PlannerReasoner	A reasoner which uses planners to find optimal sequences of behaviors based on goals
Cgrail::simgames::SimulatedGameReasoner
►Cgrail::utility::UtilityReasoner	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
Cgrail::utility::MaxUtilityReasoner
Cgrail::utility::RouletteUtilityReasoner
Cgrail::utility::roulette_selector::RouletteOptions	RouletteSelectionOptions - Struct determining options for roulette selection
Cgrail::evolution::RouletteSampler< T >	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'
Cgrail::evolution::Selection	Encapsulates the selection operation, i.e., how individuals are selected from the current population to the next generation, in evolutionary algorithm. See also EAOptimizer
Cgrail::utility::SelectionOption< ContextType >	The SelectionOption struct - Helper structure describing one of the options being selected by Selector
Cgrail::utility::SelectionOption< EntityBlackboardPair >
Cgrail::utility::SelectionResult	The SelectionResult struct - Structure containing results of operations done by Selector
Cgrail::simgames::SimulatedGame	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
Cgrail::simgames::SimulatedGameActionMetadata	This class represents action defined in the SimulatedGames module with additional statistics (score, visits)
Cgrail::data::SimulatedGameActionMetadataSnapshot
Cgrail::data::generated::SimulatedGameActionMetadataSnapshotBuilder
Cgrail::simgames::SimulatedGameHelper
Cgrail::simgames::SimulatedGameHeuristic	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
Cgrail::data::SimulatedGameIterationSnapshot
Cgrail::data::generated::SimulatedGameIterationSnapshotBuilder
►Cgrail::data::SimulatedGameMonteCarloEventSnapshot
Cgrail::data::SimulatedGameUCTEventSnapshot
Cgrail::data::generated::SimulatedGameMonteCarloEventSnapshotBuilder
Cgrail::simgames::SimulatedGameNode	This class should not be visible to developers at all
Cgrail::data::SimulatedGameReasonerSnapshot
Cgrail::data::generated::SimulatedGameReasonerSnapshotBuilder
Cgrail::simgames::SimulatedGameRuntime	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
Cgrail::simgames::SimulatedGameSnapshotObserver
Cgrail::data::generated::SimulatedGameUCTEventSnapshotBuilder
Cgrail::data::SimulatedGameUnitSnapshot
Cgrail::data::generated::SimulatedGameUnitSnapshotBuilder
►Cgrail::logger::Sink	destination of logger messages
Cgrail::logger::DefaultSink	sink writing messages to standard system output
Cgrail::logger::FileSink	sink writing messages to file
►Cgrail::fsm::State	The FiniteStateMachineState class - Class representing state of finite state machine
Cgrail::fsm::FiniteStateMachine	Class representing basic Finite State Machine
Cgrail::evaluator::StepData	The StepData struct - Helper structure describing discrete values used in Staircase function
Cgrail::data::generated::StringStringMapBuilder
Cgrail::SynchronizedEntityContainer
►CTable
Cgrail::data::generated::FLATBUFFERS_FINAL_CLASS
Cgrail::live::TCPServer
Cgrail::fsm::FiniteStateMachine::Transition
►Ctrue_type
Cgrail::BelongsToLibraryTypeGroup< T, std::void_t< decltype(SerializeLibraryType(std::declval< T >()))> >
Cgrail::BelongsToUserTypeGroup< T, std::void_t< decltype(SerializeUserType(std::declval< T >()))> >
Cgrail::CanToString< T, std::void_t< decltype(std::to_string(std::declval< T >()))> >
Cgrail::IsPair< std::pair< T, U > >
Cgrail::IsRawArray< T[]>
Cgrail::IsRawArray< T[N]>
Cgrail::IsTuple< std::tuple< T... > >
Cgrail::IsWeakPointer< std::weak_ptr< T > >
Cgrail::TupleVisitor< I >	Helpers to iterate over tuples (visitor pattern)
Cgrail::TupleVisitor< 0 >
Cgrail::live::UDPServer
Cgrail::data::generated::UintVectorOfStringMapBuilder
Cgrail::data::UtilityEvaluatorSnapshot	debug snapshot of whole evaluator tree assigned to evaluated object
Cgrail::data::generated::UtilityEvaluatorSnapshotBuilder
Cgrail::data::UtilityReasonerModel
Cgrail::data::UtilityReasonerSnapshot
Cgrail::data::generated::UtilityReasonerSnapshotBuilder
Cgrail::data::UtilitySelectorModel