|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
IComponentControllerBase.GuiceAgentModule for the bindings.GuiceAgentModule
later.
Injector created using the 'module'.
IPathExecutor that implements several trivial methods from the
interface leaving the important one to be implemented by descendants.IUT2004PathNavigator that implements AbstractUT2004PathNavigator.setBot(UT2004Bot) and
AbstractUT2004PathNavigator#setExecutor(IPathExecutorHelper).UT2004BotModuleController.getAct().
Provider interface that allows you to
set the value directly into the provider via AdaptableProvider.set(Object).UT2004Bot.botDisconnectorThread as a Runtime.addShutdownHook(Thread).
ILifecycleBus, i.e., it has become used by new agent with 'agentId'.
LogCategory plus to every new one.
LogCategory plus to every new one.
LogCategory plus to every new one.
LogCategory plus to every new one.
LogCategory plus to every new one.
IAgentLogger.addDefaultNetworkHandler() method.
LogCategory plus to every new one.
NavigationGraphBuilder.NewNavPointBuilder.edges.
ReasonFlagListener to get reasons or simple FlagListener to only receives
new values.
EventListener, etc...
AbstractAgentLogger to slip itself into the map.
LogCategory#removeLogEvent(java.lang.Object) .
ReasonFlagListener to get reasons or simple FlagListener to only receives
new values.
IStuckDetector into the executor to watch over the path execution.
ItemDescriptor).ItemType.Category#ADRENALINE.LogicModule.logic.doLogic() is called.
LogicRunner.
IAgentDescriptor.UID and IP of the host.ComponentController and defines protected methods for the control of
the module's lifecycle (AgentModule#start(), AgentModule.stop(), AgentModule.pause(), AgentModule.resume(),
AgentModule.kill() and AgentModule.reset()).ComponentDependencyType.STARTS_WITH the agent.
ComponentDependencyType.STARTS_WITH the agent.
AgentScoped)
as singletons.IWorldConnection is already connected.SharedComponentController#componentStateCountChanged().
ItemDescriptor).ItemType.Category#ARMOR.AStarMap starting from 'start' node driving
itself towards goal that is described by AStarGoal.
AStarMap starting from 'start' node driving
itself towards goal that is described by AStarGoal.
AStarMap starting from 'start' node driving
itself towards 'goal' using heuristic and extra costs defined by AStarEvaluator.
AStarMap starting from 'start' node driving
itself towards 'goal' using heuristic and extra costs defined by AStarEvaluator.
AStarMap starting from 'start' node driving
itself towards 'goal' using heuristic defined by AStarHeuristic.
AStarMap starting from 'start' node driving
itself towards 'goal' using heuristic defined by AStarHeuristic.
AStarHeuristic allowing
you to additionally specified which NODEs can't be visited at all or assign
extra cost to edges between nodes which is added to AStarMap.getEdgeCost(Object, Object)
when computing distances between them.AStarGoal.isGoalReached(Object) method.AStarHeap to compare nodes inside the heap.AStar heuristic.UT2004Bot logic module - does not synchronize the logic together with the IVisionWorldView.AgentInfo.AT_LOCATION_EPSILON.
NavigationGraphBuilder.isAutoPrefix() is on (== true), it returns 'navPointId' prefixed with "NavigationGraphBuilder.getMapName().".
IAgentStateUp.
AbstractPathExecutor
which correctly sets the path executor states along the way and provide methods for reporting failures.IPathExecutorState containing just the state.LogicModule.logic.doLogic() is called.
InitedMessage is received.
IllegalArgumentException if obj == null.
Raycasting.allRaysInitialized flag to true if all rays has been initialized.
FilePath.ALLOWED_RELATIVE_PATH_CHARS.
IStuckDetector registered inside executor via IPathExecutor.addStuckDetector(IStuckDetector)
whether the agent has stuck.
UT2004Analyzer.stopAgent() and UT2004Analyzer.killAgent() to clean up stuff (stops observers).
AgentScoped objects that the scope is holding.
IComponentBus implementors (ComponentBus).IComponentControlHelper - override only these that you need.ILifecycleBus (not only IComponentBus, you may create this ComponentController even after some 'dependencies' has started
as ILifecycleBus allows us to retrieve current state of dependencies, so we're able to start the component during the construction
if dependencies are already met.
ILifecycleBus (not only IComponentBus, you may create this ComponentController even after some 'dependencies' has started
as ILifecycleBus allows us to retrieve current state of dependencies, so we're able to start the component during the construction
if dependencies are already met.
IComponentBus (not ILifecycleBus, you must create this ComponentController before any of 'dependencies' is started
as there is no way how to retrieve state of component from 'dependencies' so we will assume that all are in state ComponentState.INSTANTIATED.
IComponentBus (not ILifecycleBus, you must create this ComponentController before any of 'dependencies' is started
as there is no way how to retrieve state of component from 'dependencies' so we will assume that all are in state ComponentState.INSTANTIATED.
ComponentController behaves - when it calls IComponentControlHelper.init()
and IComponentControlHelper.start() methods.IFatalErrorEvent.
IComponent.ComponentFuture can't be obtained.IComponent.IComponent.IStartedEvent
IPausedEvent
AbstractComponentControllerBase.component state inside the agent's bus.
IStoppedEvent.
IStoppingEvent
GuiceAgentModule.agentScope into the module and then it iterates over GuiceAgentModule.modules and
adds all their bindings to the module - each module always overrides previous ones (uses Modules.override(Module...)).
GuiceAgentFactory.newAgent(IAgentParameters) to configure the AbstractGuiceAgentFactory.getAgentModule()
with variables from 'agentParams'.
AbstractModule into the module's queue GuiceAgentModule.modules via GuiceAgentModule.addModule(AbstractModule).
GuiceAgentModule.modules using GuiceCommunicationModule#addModule(Module).
UT2004AnalyzerObserver.startAgent() after InitializeObserver command
is sent to configure the observer instance.
UT2004AnalyzerObserver.startAgent() after InitializeObserver command
is sent to configure the observer instance.
AbstractComponentControllerBase.component.
GuiceAgentModule.GuiceAgentModule() to initialize the GuiceAgentModule.agentScope,
override if you need you own AgentScope implementation.
AgentRunner#startAgentWithParams(IAgentParameters[]) to instantiate new
agents.
MultipleAgentRunner#startAgentWithParams(IAgentParameters[]) to instantiate new
agents.
CountDownLatch or its descendant initialized to 1.
IWorldView of the bot.
SharedComponentController#componentStateCountChanged().
SharedComponentController#componentStateCountChanged().
ItemType and ItemDescriptor providing
an easy way to obtain item descriptors for various items in UT2004.
AnnotationListenerRegistrator to register level A listener
(IWorldView.addEventListener(Class, cz.cuni.amis.pogamut.base.communication.worldview.event.IWorldEventListener)
for the annotated method.AgentRunner.newDefaultAgentParameters().
AgentRunner.newDefaultAgentParameters(),
i.e., we're creating a new default parameters for every 'params' from the array.
IUT2004BotController.botSpawned(GameInfo, ConfigChange, InitedMessage, Self) as a hook for Pogamut's core developers
to finalize initialization of various modules.
PathExecutorState.FOLLOW_PATH_CALLED state.
PathExecutorState.FOLLOW_PATH_CALLED from
within the BasePathExecutor.followPath(IPathFuture) method.
Jump.setDelay(Double)) if if full double jump is needed.
Jump.setForce(Double) if full double jump is needed.
Jump.setForce(Double) if full jump is needed.
FutureWithListeners object.FutureWithListeners.addFutureListener(IFutureListener)).IPathPlanner using NavPoints), you may use it to find paths inside the environment wihtout
waiting for round-trip of GetPath command and PathLists response from UT2004.
GameRestart message with GameRestarted.isFinished() is received.
GameRestart message with GameRestarted.isStarted() is received.
Future.get().
IPathFuture.getPathFrom() to IPathFuture.getPathTo().
WorldObjectId for 'name'.
WorldObjectId for 'objId'.
WorldObjectId for 'objId'.
Lazy.getVal().
Token with name "tokenStr", do not use Tokens.NULL_TOKEN string "null" as param 'tokenStr' that represents null tokens
(tokens without names).
Token of a specified 'id'.
Token of a specified 'id'.
cz.cuni.amis.pogamut.ut2004.bot.commands.Action command
module.
WeaponPref for actually used weapon.
WeaponPref for actually used weapon.
IAgentDescriptor.getCount().
IAgentId interface.
GuiceAgentFactory (or concretely by the Guice)
to instantiate the agent.
IAgentParameters interface.
AgentScoped).
IViewable instances} - those that the agent can currently see.
IViewable instances} - those that the agent can currently see.
IViewable instances} - those that the agent can currently see.
IViewable instances} - those that the agent can currently see.
AgentStats.isObserver().
Player object of the player the bot has bumped into (if it was a bot).
IComponent.
cz.cuni.amis.pogamut.ut2004.bot.commands.Communication
command module.
ComponentState of the component identified by 'componentId'.
ComponentState of the component that implements / inherit the 'cls' class.
cz.cuni.amis.pogamut.ut2004.bot.commands.ConfigureCommands
command module.
UT2004Bot#AbstractUT2004Bot(IAgentId, IComponentBus, IAgentLogger, IVisionWorldView, IAct, IUT2004BotInitialization).
IAgentDescriptor.getAgentModule().
AgentDescriptor.getAgentModule().
IMovingAverage.getAverage().
GameRestarted.
BeginMessages).
Handler that provides console publishing of all logs.
Handler that provides publishing of all logs through NetworkLogPublisher.
WeaponDescriptor for a given inventory UnrealId of the weapon.
WorldObjectId.isDoubleId(), otherwise it raises a PogamutException.
IComponentBus that the instance is working with.
FutureWithListeners.getStatus() == EXCEPTION).
UT2004AnalyzerObserver.getOutputFilePath().
GameInfo message.
WorldObjectId for the given 'annotation'.
WorldObjectId for the given 'annotation'.
Items module.
ItemType.Category) your bot has collected so far.
ItemType) your bot has collected so far (in total).
UnrealId of the weapon.
System.currentTimeMillis() when the bot changed the weapon for the last time.
StopShooting command.
ILocated.
cz.cuni.amis.pogamut.ut2004.bot.commands.AdvancedLocomotion
command module.
NetworkLogManager is using.
IAgentLogic#initializeLogic() method running time in millis.
IAgentLogic.logicShutdown() method running time in millis.
WorldObjectId.isLongId(), otherwise it raises a PogamutException.
IMovingAverage.add(Object) that are used to
compute the average returned via IMovingAverage.getAverage().
IAgentId of the bots.
IAgentId of the bots.
NavPoint instance for a given location.
NetworkLogManager is listening.
NetworkLogManager is listening.
IAgentLogger.getNetworkLoggerHost() method.
NetworkLogManager is listening.
NetworkLogManager is listening.
IAgentLogger.getNetworkLoggerPort() method.
File for a given 'pathToFile'.
AgentStats.startOutput(String) or AgentStats.startOutput(String, boolean).
IPathExecutor.isExecuting() and the path has been already computed, returns path the executor
is currently following.
AbstractPathExecutor.getPathElementIndex() is in the range
of AbstractPathExecutor.getPath().
IPathExecutor.isExecuting() and the path has been already computed, returns current path element
the executor is navigating to.
IPathExecutor.getPath() that marks the element
the path executor is currently heading to.
Game.getMapName().".
NavigationGraphBuilder.getMapName().".
Game.getMapName().".
ItemType for a weapon.
Heatup.isHot().
IRotable.
ItemType for a weapon.
cz.cuni.amis.pogamut.ut2004.bot.commands.AdvancedShooting
command module.
cz.cuni.amis.pogamut.ut2004.bot.commands.SimpleRayCasting
command module.
IllegalArgumentException will be thrown.
Items.isPickupSpawned(Item) to return all items that are believed to
be currently spawned.
Items.isPickupSpawned(Item) to return all items of 'type' that are believed to
be currently spawned.
Items.isPickupSpawned(Item) to return all items belonging to a specific 'category' that are believed to
be currently spawned.
Items.isPickupSpawned(Item) to return all items belonging to a specific 'group' that are believed to
be currently spawned.
IPathExecutor.
ILocomotive.
IViewable instances} organized according to their WorldObjectId -
those that the agent can currently see.
IViewable instances} organized according to their WorldObjectId -
those that the agent can currently see.
Weapon instance for given 'weaponType' if the bot posses it.
WeaponDescriptor for a given 'weaponType' (if it is not a weapon, returns null).
UnrealId of the weapon the bot has inside its inventory (if the bot does not have
it, returns null).
UnrealId of the weapon the bot has inside its inventory (if the bot does not have
it, returns null).
IAgent factory that instantiates the agent according to the bindigs that are found inside
the GuiceAgentModule, which is provided during the construction.Injector created using the 'module'.
AbstractModule, provides a way to hierarchically specify the bindings
for interfaces and classes.GuiceAgentModule.agentScope via GuiceAgentModule.createAgentScope().
GuiceRemoteAgentModule) that is specifying the bindings
for respective interfaces.GuiceAgentModule for the purpose of remote agents (those communicating with the world using
IWorldConnection).GuiceTeamRemoteAgentModule) that is specifying the bindings
for respective interfaces.GuiceRemoteAgentModule for the purpose of remote agents (those communicating with the world using
IWorldConnection) that is using ISharedWorldView to synchronize information within the agent's team.Weaponry.hasWeaponAmmo(ItemType).
BatchAwareWorldView.currentObjectBatch for processing?
Heatup.lastUsedMillis to current time.
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IToken, it provides an ability to give an agent a human-readable
name.AgentScoped classes as singletons.IComponent NOT ISharedComponents (for them, use ISharedComponentController instead).IComponentController or ISharedComponentController.IEmbodiedAgent not this IGhostAgent).IAgentLogger interface that is exposed via MBean.ILifecycleBus is extending IComponentBus by implementing the knowledge of lifecycle states of various IComponents.Listeners or ListenersMap.Flag whhich value cannot be set.Weapon / / WeaponPrefs you want to shoot.SharedComponentController#componentStateCountChanged().
SharedComponentController#componentStateCountChanged().
UT2004Bot before the GameBots2004 greets the bot even before
IUT2004BotController.prepareBot(UT2004Bot) method.
UT2004BotModuleControllerNew#listenerRegistrator and calls AnnotationListenerRegistrator.addListeners() method
to probe all declared methods for event-annotation presence.
UT2004BotModuleControllerNew#pathPlanner, UT2004BotModuleController.fwMap and UT2004BotModuleControllerNew#pathExecutor.
PathExecutorState.INSTANTIATED state.
IPathExecutor javadoc - do it now! Following javadoc assumes you know what IPathExecutor is
and how its interface works.IPathExecutor providing a high-level description of the state via
IPathExecutorState.getState().IPathPlanner and IPathExecutor.IPathPlanner computation.IPausingEvent and
IAgentResumingEventNavigationGraphBuilder is auto prefixing all navpoint ids with current map name.
Heatup.isHot().
IAgentLogger.isDefaultNetworkHandler() method.
WorldObjectId.token.
IMovingAverage.getCurrentLength() == IMovingAverage.getMaxLength().
IPathFuture
and working on getting the bot to its target.
Flag.defreeze() is called.
ISharedComponent NOT IComponents (for them, use IComponentController instead).Cooldown.isCool().
GameRestarted? Default: TRUE.
WorldObjectId.token.
WorldObjectId.isLongId() or WorldObjectId.isDoubleId()).
NetworkLogManager#shutdown().
IStartingEvent, it marks that the component is going to start.BeginMessage in order to have all time-vars initialized
so we may collect all stats.
ILifecycleBus and is watching it for auto start/stop/pause/resume/...
ISharedWorldView instance that should be used by the particular agent.ITeamAgentParameters and IRemoteAgentParameters.ItemType and ItemDescriptor providing
an easy way to obtain item descriptors for various items in UT2004.EndMessage listener.ItemPickedUp listener.ItemType.Category the bot has collected.
ItemDescriptor.IUT2004AnalyzerObserver agent onto
every bot inside UT2004 game sniffing info about the bot.IPathExecutor
and UT2004PathExecutor documentation, do it now.ComponentDependencyType.STARTS_WITH the agent.
ComponentDependencyType.STARTS_WITH the agent.
IniFile.Section.getKeys().
IFatalErrorEvent, tear down the whole system!
DefaultPogamutPlatform.close() to shutdown the network
logging, terminating its thread to let JVM die gracefully.
FutureWithListeners.get() or FutureWithListeners.get(long, TimeUnit).
ILifecycleBus which is extending IComponentBus by implementing the knowledge of lifecycle states of various IComponents.DefaultLogFormatter.lineEnd after the log message.
MainAgentRunner#latch (if reaches zero, start method resumes and closes the Pogamut platform),
and watches for the agent's failure (MainAgentRunner#killAgents(IAgent[]) in this case).
MultipleAgentRunner.latch (if reaches zero, start method resumes and closes the Pogamut platform),
and watches for the agent's failure (MultipleAgentRunner#killAgents(IAgent[]) in this case).
EventListener, ObjectClassEventListener,
ObjectClassListener, ObjectEventListener and ObjectListener annotations and automatically registers
them as listeners on a specific events.
FutureWithListeners.addFutureListener(IFutureListener).
IniFile#source into IniFile.sections.
AbstractComponentControllerBase.component inside
bus of respective agents.
IComponentController provided by respective ILifecycleBus.addLifecycleManagement(IComponent, IComponentControlHelper, ComponentDependencies)
of agents using the component.
IPausingEvent of the component is broadcast into ILifecycleBus of
the agent identified by 'agentId'.
IResumingEvent of the component is broadcast into ILifecycleBus of
the agent identified by 'agentId'.
IStartingEvent of the component is broadcast into ILifecycleBus of
the agent identified by 'agentId'.
IStartingPausedEvent of the component is broadcast into ILifecycleBus of
the agent identified by 'agentId'.
IStoppingEvent of the component is broadcast into ILifecycleBus of
the agent identified by 'agentId'.
IResetEvent is caught at the ILifecycleBus of the agent identified by 'agentId'.
ILifecycleBus of the agent identified by 'agentId'.
LogCategory to add events to the log.LogEventMark.LogPublisher.IAgentLogic.logic() invocation.
IAgentLogic.logic() is periodically called - allows you to sleep the logic until the rest of the agent is ready.
LogicModule is stopping to end the logic.
LogCategory to place mark on the map.IUnrealServer implementors when the map change fails.IUT2004Server implementors when the map change fails.ImprovedShooting.setChangeWeaponCooldown(long)).
IWorldChangeEvent from the IWorldChangeEventOutput
passing them to the without any delay.NavigationGraphBuilder.ExistingNavPointEdgeBuilder.createEdge().
NavPoint instance, if navpoint of specified id is not found, an exception is thrown.
BasePathExecutor.followPath(IPathFuture) and
BasePathExecutor.stop() methods.
IAgentId, see IAgentParameters.assignDefaults(IAgentParameters).
IAgentId, see IAgentParameters.assignDefaults(IAgentParameters).
IAgentId, see IAgentParameters.assignDefaults(IAgentParameters).
IAgentId, see IAgentParameters.assignDefaults(IAgentParameters).
IAgentId, see IAgentParameters.assignDefaults(IAgentParameters).
UT2004PathExecutor to continue the navigation of the bot
inside the UT2004.
NavigationGraphBuilder.ExistingNavPointModifier.createEdge(),
NavigationGraphBuilder.ExistingNavPointModifier.createEdgeTo(String), NavigationGraphBuilder.ExistingNavPointModifier.modifyEdgeTo(String) methods.NetworkLogManager.NetworkLogManager publishes.AbstractAgentLogger that passes all the logs into NetworkLogManager.IAgent interface that is cast to AGENT parameter.
UT2004BotFactory for agent construction.
AgentId from the 'name' and unique number that is automatically generated
from the AgentRunner.ID.
AgentId from the 'name' and unique number that is automatically generated
from the MultipleAgentRunner.ID.
IAgentId using MultipleUT2004BotRunner.name and SocketConnectionAddress
using MultipleUT2004BotRunner.host and MultipleUT2004BotRunner.port.
IAgentId using UT2004AnalyzerRunner.name and SocketConnectionAddress
using UT2004AnalyzerRunner.host and UT2004AnalyzerRunner.port.
IAgentId using UT2004BotRunner.name and SocketConnectionAddress
using UT2004BotRunner.host and UT2004BotRunner.port.
IAgentId using UT2004ObserverRunner.name and SocketConnectionAddress
using UT2004ObserverRunner.host and UT2004ObserverRunner.port.
IAgentId using UT2004ServerRunner.name and SocketConnectionAddress
using UT2004ServerRunner.host and UT2004ServerRunner.port.
UT2004PathExecutor reports that new path has been received and the IUT2004PathNavigator#navigate()
is about to be called in near future.
WeaponPrefsRange, these weapon will be used when the target is at "maxDistance" afar.
AnnotationListenerRegistrator to register level C listener
(IWorldView#addObjectListener(Class, Class, cz.cuni.amis.pogamut.base.communication.worldview.object.IWorldObjectListener)
for the annotated method.AnnotationListenerRegistrator to register level B listener
(IWorldView#addObjectListener(Class, cz.cuni.amis.pogamut.base.communication.worldview.object.IWorldObjectListener)
for the annotated method.IViewable objects raising WorldObjectAppearedEvent automatically (if object is visible).
IViewable objects automatically raising WorldObjectDisappearedEvent if object was visible
before it was destroyed.
AnnotationListenerRegistrator to register level E listener
(IWorldView#addObjectListener(WorldObjectId, Class, cz.cuni.amis.pogamut.base.communication.worldview.object.IWorldObjectListener)
for the annotated method.AnnotationListenerRegistrator to register level D listener
(IWorldView#addObjectListener(cz.cuni.amis.pogamut.base.communication.worldview.object.WorldObjectId, cz.cuni.amis.pogamut.base.communication.worldview.object.IWorldObjectListener)
for the annotated method.EventDrivenWorldView.innerNotify(IWorldChangeEvent) if the event is IWorldObjectUpdatedEvent
to process it.
IViewable objects automatically raising WorldObjectAppearedEvent and
WorldObjectDisappearedEvent.
EventDrivenWorldView.innerNotify(IWorldChangeEvent) if the event is IWorldObjectUpdatedEvent
to process it.
ItemDescriptor).ItemType.Category#OTHER.IniFile into the 'writer'.
IniFile as string.
UT2004AnalyzerObserver#observerFile.
AgentStats.outputFile is not null, was initialized by AgentStats.startOutput(String) or AgentStats.startOutput(String, boolean)).
PathExecutorState.PATH_COMPUTATION_FAILED state.
PathExecutorState.PATH_COMPUTED state.
PathExecutorState.PATH_COMPUTATION_FAILED from
within the BasePathExecutor.pathComputationFailed() method.
BasePathExecutor.pathFuture.
PathExecutorState.PATH_COMPUTED from
within the BasePathExecutor.pathComputed() method.
IUT2004PathNavigator.newPath(List)
and set the path into the GB2004 via SetRoute.
IPathExecutor state.IPathFuture interface that assumes the computation to be
dependent on some IComponents.IComponent.
IAgentStateRunning
Requests.getLastPong() to see the results.
ObjectNames for various Pogamut components (classes).ObjectName instance can't be obtained.MBeanServer interface, that is using to store references of
registered mbeans and listeners allowing to unregister/register them again using
PogamutMBeanServer.unregisterAll() and PogamutMBeanServer.registerAll().PogamutProperty.toString() method.IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
IAgentParameters.assignDefaults(IAgentParameters).
EventReact.react(IWorldEvent) hook allowing you to do additional work after the react method.
EventReact.react(IWorldEvent) hook allowing you to do additional work after the react method.
ObjectEventReact#react(IWorldEvent) hook allowing you to do additional work after the react method.
AgentRunner.factory
and started with IAgent.start().
MultipleAgentRunner#factory
and started with IAgent.start().
AgentRunner.factory and
started with IAgent.start().
IAgent.start().
IPathFuture that contains pre-set result, i.e., you do not need the future, you just want to pass down
some value...PathExecutorState.FOLLOW_PATH_CALLED from within
the BasePathExecutor.followPath(IPathFuture) method.
AgentRunner.factory.
ComponentBusEvents.fatalError(String) event is broadcast.
UT2004Bot before the GameBots2004 greets the bot.
Injector.
PathExecutorState.PATH_COMPUTATION_FAILED from within
the BasePathExecutor.pathComputationFailed() method.
PathExecutorState.PATH_COMPUTED from within
the BasePathExecutor.pathComputed() method.
IPausingEvent of the component is broadcast.
EventReact.react(IWorldEvent) hook allowing you to do additional work before the react method.
EventReact.react(IWorldEvent) hook allowing you to do additional work before the react method.
ObjectEventReact#react(IWorldEvent) hook allowing you to do additional work before the react method.
IResumingEvent of the component is broadcast.
AgentRunner.isPausing().
MultipleAgentRunner.isPausing().
IStartingEvent of the component is broadcast.
AgentRunner.factory and before
the IAgent.start() is called.
IAgent.start() is called.
Level.WARNING here so the bot won't log much.
IStartingPausedEvent of the component is broadcast.
IStoppingEvent of the component is broadcast.
ComponentBusEvents.stopping() event is broadcast.
PathExecutorState#STUCKD from within the
BasePathExecutor#stuck(IStuckDetector) method.
PathExecutorState.SWITCHED_TO_ANOTHER_PATH_ELEMENT from within
the BasePathExecutor.switchToAnotherPathElement(int) method.
PathExecutorState.TARGET_REACHED from within the
BasePathExecutor.targetReached() method.
AbstractPathExecutor.getPath().
Provider to by of type "T".AutoTraceRay that is being utilized).AutoTraceRay that is being utilized).
ReasonFlag.NavigationGraphBuilder.
UT2004Bot.botDisconnectorThread as a Runtime.removeShutdownHook(Thread) and nullify the field.
ILifecycleBus, i.e., it has stopped to be used by agent with 'agentId'.
LogCategory.
LogCategory.
LogCategory.
LogCategory.
IAgentLogger.removeDefaultNetworkHandler() method.
LinkFlag.DOOR flag from edge flags.
LinkFlag.FLY flag from edge flags.
LinkFlag.FORCED flag from edge flags.
LinkFlag.JUMP flag from edge flags.
LinkFlag.LADDER flag from edge flags.
LinkFlag.PLAYERONLY flag from edge flags.
LinkFlag.PROSCRIBED flag from edge flags.
LinkFlag.SPECIAL flag from edge flags.
IStuckDetector from the executor (must be the same instance, equals() is NOT USED).
LinkFlag.SWIM flag from edge flags.
LinkFlag.WALK flag from edge flags.
IResetEvent is caught.
IResetEvent is caught in any of stopped bus.
UT2004PathExecutor reports that execution of current path has been terminated - clean up your internal data
structure and prepare to navigate the bot along the new path in the future.
IComponentBus broadcast IResetEvent to reset all agent's components as well
as an agent.
AgentStats.getCurrentMatchTime() > 0).
AgentStats.getCurrentMatchTime() (use AgentStats.resetMatchTime() for that purpose separately).
IAgentStatePaused
Self object that is lazy-initialized inside AbstractUT2004PathNavigator.self.
IniFile.Section.put(String, String).
Lazy.get().
IUT2004Server#stop() and IUT2004Server#start().
IAgent.stop() and IAgent.start().
AbstractGuiceAgentFactory.injector
so the new one is created when AbstractGuiceAgentFactory.getInjector() is called.
AgentDescriptor and assigns 'params'.
UT2004Bot instance that the navigator should navigate.
NavPointNeighbourLink.getCollisionH().
NavPointNeighbourLink.getCollisionR().
IViewable objects.
LinkFlag.DOOR flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
NavPointNeighbourLink.isForceDoubleJump().
IPathExecutorHelper who is using the navigator, i.e., are calling its
IUT2004PathNavigator#navigate(Self) and IUT2004PathNavigator.reset()
methods.
LinkFlag.FLY flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
LinkFlag.FORCED flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
NavPoint.getId().
LinkFlag.JUMP flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
LinkFlag.LADDER flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
NavPoint.getLocation().
GameRestarted event.
Level.WARNING).
Level.WARNING).
IAgentId of the bots.
IAgentId of the bots.
NavPointNeighbourLink.getNeededJump().
UnrealId that is present for instance in Self#getId())
of the bot that is going to be observed by newly created observer.
UT2004AnalyzerObserver in
order to sniff info about connected bots.
LinkFlag#PLAYERONLYK flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
LinkFlag.PROSCRIBED flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
ISharedWorldView that should be used by this agent.
LinkFlag.SPECIAL flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
AbstractComponentControllerBase.componentState to desired state.
SharedComponentController#componentStateCountChanged().
SharedComponentController#componentStateCountChanged().
LinkFlag.SWIM flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
IWorldObjectUpdatedEvent.
NavPointNeighbourLink.getToNavPoint().
NavPointNeighbourLink.getToNavPoint().
NavigationGraphBuilder.isUsed().
LinkFlag.WALK flag into NavigationGraphBuilder.NewNavPointEdgeBuilder.flags of the new navpoint edge,
corresponds to NavPointNeighbourLink.getFlags().
ISharedComponentControlHelper - override only these that you need.ISharedComponent
while providing methods that has to be implemented by any ISharedComponent.IComponentControlHelper that is passed to every ILifecycleBus.addLifecycleManagement(IComponent, IComponentControlHelper, ComponentDependencies)
sensing decisions of ordinary ComponentController that signalizes when the component should be started for a given bus.EventDrivenWorldView.innerNotify(IWorldChangeEvent) if the event is IWorldObjectUpdatedEvent
to process it.
ItemDescriptor).ItemType.Category#SHIELD.WeaponPref.getWeapon() primary/secondary (as specified) at 'target'.
WeaponPref.getWeapon() primary/secondary (as specified) at 'target'.
Weapon.getType() primary/secondary (as specified) at 'target'.
Weapon.getType() primary/secondary (as specified) at 'target'.
WeaponPref.getWeapon() primary/secondary (as specified) at 'target'.
WeaponPref.getWeapon() primary/secondary (as specified) at 'target'.
Weapon.getType() primary/secondary (as specified) at 'target'.
Weapon.getType() primary/secondary (as specified) at 'target'.
AdvancedShooting.shootPrimary(UnrealId).
AdvancedShooting.shootPrimaryCharged(UnrealId, double).
AdvancedShooting.shootSecondary(UnrealId).
AdvancedShooting.shootSecondaryCharged(UnrealId, double).
LogicModule.logic.logic() will be called.
AgentRunner#startAgentWithParams(IAgentParameters[]) to start newly
created agent.
MultipleAgentRunner#startAgentWithParams(IAgentParameters[]) to start newly
created agent.
UT2004AnalyzerObserverParameters.getObservedAgentId() that is obtained from
the UT2004AnalyzerObserver.getParams().
AbstractPathExecutor.stop().
PathExecutorState.STOPPED from within the
BasePathExecutor.stop() method.
AgentStats.outputFile and AgentStats.fileToOutput.
PathExecutorState.STOPPED from
within the BasePathExecutor.stop() method.
PathExecutorState.STOPPED state.
Level.INFO) as default.
Level.INFO) as default.
PathExecutorState.STUCK that should be called whenever some
stuck detector detects that the agent is stuck.
PathExecutorState.STUCK state.
IStuckDetector
or some other part of the IPathExecutor.
PathExecutorState.STUCK from
within the BasePathExecutor#stuck(IStuckDetector) method.
PathExecutorState.SWITCHED_TO_ANOTHER_PATH_ELEMENT state.
AbstractPathExecutor state into AbstractPathExecutor.state.
PathExecutorState.SWITCHED_TO_ANOTHER_PATH_ELEMENT from
within the BasePathExecutor.switchToAnotherPathElement(int) method.
SetRoute whenever switch occurs and the rest of the path is greater than
32 path elements.
Lazy that has synchronized Lazy.create() method (you do not need to synchronize it for yourself).PathExecutorState.TARGET_REACHED state.
PathExecutorState.TARGET_REACHED from
within the BasePathExecutor.targetReached() method.
Map as keys or Sets as
Token.equals(Object) has O(1) time complexity which is much better when
compared to the O(N) time complexity of String.equals(Object).Token.getNameWithIds().
DisconnectBot commands to GB2004, eats up all exceptions.
Cooldown.isCool(), if so, save current time as the time of the use and returns true,
otherwise (== effect needs more cooldown, see Cooldown.getRemainingTime()) returns false.
EndMessage is received, writes another line into the UT2004AnalyzerObsStats#outputFile.
Cooldown.lastUsedMillis to current time.
Charset that is used by the NetworkLogManager to send logs over the socket.
UT2004BotController.log instead
IAgentId and ISocketConnectionAddress.UT2004AgentParameters.setAgentId(IAgentId), UT2004AgentParameters.setWorldAddress(IWorldConnectionAddress).
IUT2004Server factory.IUT2004AnalyzerObserver, does not add that much functionality, except
starting the observation for desired agent and abide watching out for GameRestarted so you
have easy work to restart the observation data collection (and to abide UT2004AnalyzerObserverParameters.isWaitForMatchRestart()).UT2004Analyzer.UT2004AnalyzerParameters.setAgentId(IAgentId), UT2004AnalyzerParameters.setWorldAddress(IWorldConnectionAddress),
UT2004AnalyzerParameters#setObserverModule(UT2004ObserverModule).
IPathFuture implementation that is using UT2004 inner AStar algorithm for finding the path inside UT2004
environment.IUT2004Bot factory.UT2004CommunicationModule for the purpose of UT2004Bot instantiation.RemoteGuiceAgentModule for the purpose of UT2004 communication specification.UT2004Observer class.IUT2004Observer factory.UT2004CommunicationModule for the purpose of UT2004Observer instantiation.UT2004Server class.IUT2004Server factory.UT2004CommunicationModule for the purpose of UT2004Server instantiation.IStuckDetector that watches whether the bot moves at all.IVisionLocalWorldView interface.IComponentEvent may be really substitued as T.WeakHashMap.Shoot command
has been effective for the bot.
UT2004BotController.getWorldView().
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||