this method ensures, that bot is on the place he should be at
means it can have one affordance, which demands a location - like swimming needs a pool
and so it just ensures agent is on that location:)
makes hard copy of a subtree starting at action via Serializable, as decision module and agent are transient
it sets those manually after acquiring hard copy
Confirms that he goes to the training -> means he goes to the computer and "sends" a message
on the forum to notify his team mates that he is coming to the training
main decision making module - presents the logic of the bot!
it takes care about everything about the main logic cycle
choice of intention to be performed, action to be performed, update of fadeout, attractivity,
rollback when something fails, update of attractivity of intentions etc.
What I want to show?
- intention area - name, activation, parent name
- daily plan - intention name and activation intervals
- action area - name activation, attention
- perceived items - together with visible - like make those bot perceives bold for instance
- visible items - name, attention (attractivity)
so I will have 4 tables
###########################
# int area # act area #
###########################
# daily plan # items #
############$##############
# info panel #
##############
executes an atomic action
if there is not any -> successful execution of the action -> TERMINATED
if there is one -> execute it
this can be done for a long time (as the atomic actions fails or succeeds depending on the environment)
it can fails by timeout as well...
Sends FOLLOW to the global message channel thus provoking the Commandable bot to follow him, thought there
should be some kind of handshake, where the commandable bot would send a confirmation of the reception -> e.g.
Intention is one of the crucial classes of this decision making model
it represents an "OR" node of the tree, so it contains a set of actions
by which it can be satisfied (it suffices to succeed with one of them)
this class serves for definition of functions of activation of root processes so
it will be possible to export and import it via XML
though that brings some limitation on their specification, they can be only linear
technicaly we can write the Interval more as a Function or something so it will have some more
parameters and will calculate according to them some polynom for instance.
Item record serves to store item memory information about an item
it does not store anything but the location, affordances and cathegory of the original EItem
but it adds other variables - missed, found, seen, time which indicate
when was the last time the record was modified and how many times bot
found, missed (not found) and saw the thing on the location
Perceptive field is taking care about the actions and their link with items (satisfaction of affordances)
therefore it contains link to ThingManager and structures to hold currently perceived items
and actions, which are active and compete to be executed
real time limit - means in the MINUTES, should be given in the action description in the XML
on the other hand timeLimit will be overridden by the calculated value from realTimeLimit
and the number of iterations for a day
removes action from processArea
removes descendant intentions of action
be careful about Want intentions as they can be descendants of more than one action
so far just removes intention from intention area without anything else as intentions are rolling back differently
and when one fails it doesn't mean a disaster - so just the parent action failed as well.
this procedure tries to restrict the time limits, so the subactions of the intention would fail/end earlier then normaly
so far it restrains the interval to 2/3 of the given restrain for each subaction -> though with a bit more effort it can do it exactly
like count the time before, make it proportional and set it according to it, but as it is not crucial, I made it this way
rnd -
Variable in class decisionMakingSystem.Scheduler
This structure is used to store the schedule entries,
example: when we want agent to go to school for
few months we add to the planing.xml a record with:
intention = IStudy
weeks = list of intervals of weeks -> (0-12) will tell him to go there for first 3 months
executionTimes - [(1, 1, 1.0) ; (2, 2, 0.5) ; (4, 3, 0)] will say, that bot studies every monday morning,
tuesday afternoon on fifty percent and is not studying thursday evenings
(though this is implicit and doesn't have to be included)
Sleep just leave agent sleeping - so it doesn't perform any exernal action, it just means agent will freeze
on the spot sleeping, so it never succeeds, it just fails on timeout
Sleep() -
Constructor for class atomicActions.Sleep
updates activity of the intention according to the habituation/activation function
counts with dropout first - no need to restart it - it will be overriden later anyway
updates values of fadeout in all items - if the item is not perceived, it fades out of
agent perception -> removed from perceivedItems
same thing for processes - if process doesn't have activity big enough to get to execution, its fading out