---------------------------
version 1.3.3

revision 1603 on SVN
---------------------------

New features
- creation of meta events for goal state change.
  States are:
        - created      the goal has been crated, e.g. !g in a plan
        - finished     the goal has been achieved, e.g. a plan for !g 
                       has finished
        - failed       e.g. the goal has failed
        - suspended    the goal has been suspended by .suspend,
                       .wait, and action, ...
        - resumed      the goal has been resumed by .resume

  the syntax for meta-events is
	^<goal type><goal literal>[state(<s>)]
  where <goal type> is ! or ?
        <s> is one of the above states
  these events can than be handled by plans such as
	^!goto(X,Y)[state(S)] <- .print("goto state is ",S).
  for the state suspended, another annotation contains the 
  suspension reason (.wait, .suspend, É)
	^!goto(X,Y)[state(S)[reason(R)]] 
           <- .print("goto state is ",S," due to ",R).
 
  see demos/meta-events for an example

---------------------------
version 1.3.2

revision 1586 on SVN
---------------------------

New features

- backtracking on annotations
  (and literal's annotations are sorted)

API changes
- a new listener can be added in TS to be notified about
  changes in goals state (there are methods for created, 
  suspended, resumed, finished, and failed goals)
  (see new class GoalListener)

Changes in the syntax
- syntax of if/while/for statements are now like C/Java:
      if ( X > 3) {
           bla;
      } else {
           bla;
      }
  ";" is not required after "}"
  last formula in <then> can be followed by ";"
  keyword "else" is used

Bugs fixed
- equals in ObjectTermImpl,
  as reported by Tim Cleaver in jason-bugs list
- unnamed variables in some rules are not correctly replaced, 
  as reported by Tim Cleaver in jason-bugs list
- "E+1" is parsed as <exponent> instead of arithmetic expression
- .relevant_plan with meta-variable plans
  as reported by Iain Wallance
  
  
---------------------------
version 1.3.1

revision 1553 on SVN
---------------------------

New demo
- use of controllers to write a customised mind inspector

Internal actions
- .random has an optional second parameter to setup backtrack

Bugs fixed
- foreach when no solution exists causes failure
- perception of atoms cause failure with SACI
- initialisation of TimeSteppedEnvironment (bug: waits for a first action to start)
- .succeed_goal does not work when applied to 'itself' (the intention succeed itself)
- !Var does no work correctly

---------------------------
version 1.3

revision 1489 on SVN
---------------------------

New features
- Plans and Triggers can be used as terms when enclosed by { and }
  
  This feature is used in the following internal actions
  .relevant_plans
      e.g.       .relevant_plans({ +!g(_) }, ListOfPlans)
      instead of .relevant_plans( "+!g(_)" , ListOfPlans)
  .add_plan
  .at
  .wait
  
  It may be used in send tellHow
  .send(bob, tellHow, { +te : c <- a1 }).

  It is also used by internal actions that 'return' plans, like
  . plan_label
  . relevant_plans
  . current_intention
  
  The advantages are that unification works
       e.g. .at("now +1 m", {+stop(ID)})
  and syntax errors are detected at compilation time

  The old style (with strings) continues to work.
  
  More complex meta-programming is also possible:
  .... !myadd( { .print(a); .print(b) } ) .... 
       // pass the body of the plan as parameter to !myadd
       
  +!myadd(Action) <- .add_plan( {+!g : c & b <- Action} ).
      // add a plan with a fixed event/context and body 
      // given as a parameter  
  
- The performance is improved (+- 15%) by not cloning all the
  plan in the creation of intended means
  
  
Changes in the GUI
- When closing the window of MAS Console, the application is also
  stopped.


Changes in communication
- for messages sent to itself, the sender is 'self' now, 
  and not the agent's name as in previous releases


New internal actions
- .puts: used for printing messages to the console (based on Ruby
  similar method). Developed by Felipe Meneguzzi.
- .all_names: get the name of all agentes in the system.
- .list_plans: print out the plans of agent's plan library
- .prefix, .suffix and .sublist: see comments in the API doc, as
  their implementation is currently generates slightly different results
  from their usual implementation in logic programming.


Changes in internal actions
- .relevant_plans has a third argument that gets the labels
  of the plans
- .create_agent and .kill_agent accept strings for the agents' name


New example
- Blocks World


Bugs fixed
- arithmetic expressions are considered as Literal, causing 
  failures in unification
- variable unified with atom cannot be added in BB, as in 
  X = p; +X; 
- The third argument of .create_agent (list of options) can
  not be used.
- Some concurrent execution of .wait and .drop_desire/intention
  does not work (the intention isn't dropped)
- send askHow with 4th argument blocks the intention
- TimeSteepedEnvironment wait timeout when it is not required to wait

---------------------------
version 1.2
the 5th Anniversary Release

revision 1428 on SVN
---------------------------

New features
- customised belief bases can be organised in a chain so
  that several functionalities can be composed. For more
  information
  see the demo/chain-bb
  see API doc of ChainBB and ChainBBAdapter

- annotations in failure events. All failure events are now
  annotated with:
     error(<atom: error id>): the identification of the type of error, 
     values used by Jason are:
          no_applicable: no applicable plan
          no_relevant: no relevant plan
          no_option: no option selected
          constraint_failed: constraint (i.e., a logic expression in
              the plan body) failed
          ia_failed: internal action returned false
          action_failed: environment action failed
          ask_failed: answer to an ask message failed (due to timeout)
          wrong_arguments: wrong arguments (type and/or number) passed
              to an internal action

     error_msg(<string>): the human readable message for the error
     code(<literal>): the part of the plan body where the failure occurred
     code_src(<string>): the file where the failure was
     code_line(<int>): the line in that file
  see demo/failure for an example
  see FAQ for more details
  see code of JasonException and TS for more information

- the version of JADE is upgraded to 3.6

- new base class for internal actions: ConcurrentInternalAction. This
  class can be used in place of DefaultInternalAction to create an IA
  that suspends the intention while it is being executed. For example,
  if DefaultInternalAction is used for an action that requires user
  input, the agent's thread is blocked until an answer is given by the
  user. With ConcurrentInternalAction, only the intention using the IA
  is suspended. See demos/gui/gui1 and the API doc of this new class.

- API doc uses UMLGraph to show relations between classes


New demo
- java-object-terms: shows how variables may be unified to
  Java objects


New internal actions
-  .term2string: transforms a term into a string and vice-versa


New functions
-  .math.sum: sums a list of numbers
-  .math.average: returns the average of a list of numbers


API changes
- the most significant change is in the Literal class, which
  is now abstract. To create a new literal, the previous method
      Literal.parseLiteral(....)
  still works, but 
      new Literal(...)
  has to be written as
      ASSyntax.createLiteral(....)
  the ASSyntax factory is the preferred approach for the creation of all
  types of terms.
  see API doc for further details.
  see discussion about the Literal class in the jason-developers list.


-------------
version 1.1.2
-------------

New features
. (experimental) control of the execution in plan bodies with if, while,
  and for.

  --- if ----
  syntax:

  if ( <logical formula> ) {
     <plan_body1>
  [ } else { <plan_body2> ]
  };

  if <logical formula> holds, <plan_body1> is executed; otherwise, 
  <plan_body2> is executed.

  e.g.: if (vl(X) & X > 10 & X < 20) { // where vl(X) is a belief
           .print("value > 10 and ");
           .print("value < 20")
        }

  --- while ---
  syntax:

  while ( <logical formula> ) {
    <plan_body>
  };

  while <logical formula> holds, the <plan_body> is executed.

  e.g.: while (vl(X) & X > 10) {
           -+vl(X+1)
        }

  --- for ---
  syntax:

  for ( <logical formula> ) {
    <plan_body>
  };

  the <plan_body> is executed for all unifications of <logical formula>.
 
  e.g.: for ( vl(X) ) {
          .print(X)
        };
        for ( .member(X,[a,b,c]) ) {
          .print(X)
        };
        for ( .range(I,1,10) ) {
           .print(I)    // print all values from 1 to 10
        };
 

New examples and demos:
. demos/gui: two simple examples of how to make a GUI for individual agents
. example/food-simulation: implementation of the scenario of simulation
        presented in http://jasss.soc.surrey.ac.uk/1/3/3.html

Bugs fixed:
. BUF didn't add annotation "source(percept)" in the perception deletion event
. drop_desire did not remove desires in Circumstance.Event correctly 
  when annotations are used
. print worked like println
. problem in =.. with atoms
. problem in unification when unbound vars were used as arguments
  for rules (as identified by Stephen Cranefield)

-------------
version 1.1.1
-------------

New features
. Terms can be body plans enclosed by "{ ... }", as in the following
  example:
     test({ a1; !g; ?b(X); .print(X) }, 10)

Bugs fixed:
. unification in return of ! and ?
. use nested source annotations in communication 
. add "source(self)" in goals without source
. correctly handle failure event caused by no relevant plans 
. timeout in .wait does not cause a runtime exception


-------------
version 1.1.0
-------------

New features
. Performance improvements: in general, applications run 30%
  faster.

. Arithmetic functions: math.abs, math.max, ...
  see doc/index.html and demo/function for more information

. Compiler warns about "singleton variables" in plans and rules
  (see plugin options to disable this feature). If you don't use
  anonymous variables for logical variables whose contents will
  not be used, you may want to disable this feature.

. Terms can be logical expressions, as in the following
  example of .findall usage:
     .findall(X, (a(X) & X > 10), L)

. A list of goals can be sent with the "achieve" performative:
     .send(bob,achieve,[g1,g2,g3])
  Note that each goal will become a separate intention of bob 
  (if the message is accepted).

New example:
. the Jason team used in the Agent Contest 2007 was added to the
  examples (folder gold-miners-II)
. a GUI was added to the IPD example

New demo:
. function: shows how to create new arithmetic functions.

New internal actions:
. .reverse: reverse the order of lists and strings.
. .union, .intersection and .difference of sets.

Bugs fixed:
. the internal action .concat did not clone the lists properly
. +?b(X) plans did not "return" the X value (bug in 1.0.1 only)
. +!A used to catch events of the form +p
. JDBC belief base did not work with null values
. The MAS did not stop running when the "stop" button is pressed
. The parser allowed mixing initial beliefs and goals with plans.


-------------
version 1.0.1
-------------

New features
. a new entry is added in the mas2j project: aslSourcePath. This entry
  allows the developer to set where the runtime will search for AgentSpeak
  sources. E.g:

     MAS ts {
       agents: a; b; c;
       aslSourcePath: "."; "src/asl"; "kk";
     }

  search the sources of agents a, b, and c in the paths "." (current path),
  "src/asl", and "kk". 
  The default value is the project's directory.
  
. a preliminary version of an eclipse plugin (http://jasonplugin.wikidot.com) 

New documentation
. A getting started with Jason (see doc/index.html)
. A mini-tutorial of interoperability between Jason and JADE (see doc/index.html)

New Demo
. demo/sync-environment shows how to use the SteppedEnvironment. 
  This environment has steps where each agent can perform only one action.
  When all agents have asked for the execution of an action, the actions
  are really executed, the perception is updated and the next step starts.
  The game-of-live example is also updated to use this kind of
  environment.

New internal actions
. .suspend and .resume were moved from the example to the standard library.
  They can thus be used in any Jason application.
. .delete to remove elements from lists or strings

Bugs fixed
. clone example
. use-only-jason-bdi example
. the save files when opening a new project locks the jEdit
. parser accepts initial goals and beliefs mixed with plans


-------------
version 1.0
-------------

Jason v 1.0 is used in the book 
'Programming Multi-Agent Systems in AgentSpeak using Jason'

New feature
. the centralised infrastructure can use a thread pool instead of
  one thread by agent. It is useful to run thousand of agents.
  See demo/big and examples/game-of-life for more details.

New Demo:
. demo/clone shows how an agent can create a clone of itself.


-------------
version 0.9.7
-------------

New features:
. First (experimental) version of JADE infrastructure 
  (see FAQ for details)
. Mind inspector has "bi-directional" debug and other improvements.

New example:
. iterated-prisoners-dilemma

New Demos:
. tell-rule: implements a new performative to tell rules like
       a :- b & c.
  to other agents.

. suspend-resume: implements two useful internal actions: one to
  suspend intentions and other to resume them.

Bugs fixed:
. JavaWebStart of Jason applications in windows.

Changes:
. new beliefs are added before the others in the belief base.
. asynchronous acting in centralised infrastructure.


-------------
version 0.9.6
-------------

New features
. test goal now can also have expressions, as in:
	+e : true <- ... ?(a & b | d); ...
  unlike simple test goals, the event +? will not be generated
  in case the test fails. As before, simple expressions that make
  no reference to the belief base don't need to be in a test goal.
. when an error occurs during the execution of a plan,
  the corresponding line in the source code is shown
  in the console.
. the build.xml file created for each Jason application has two
  new tasks:
  "jar": creates an executable jar for the application
  "jnlp": creates a JavaWebStart application

New internal actions
. min(<list>,<term>) gets the minimum value from the list.
. max(<list>,<term>) gets the maximum value from the list.
. .drop_event(D) removes the event +!D from the set of events

Changes in internal actions
. .drop_desire(D) also removes the intentions related to +!D.
. .drop_all_desires also removes all intentions.

Bugs fixed
. broadcast did not work with SACI.
. persistent BB in text files did not work
. strong negation was not shown in the mind inspector
. initial beliefs with negative arguments were not shown in
  the mind inspector


-------------
version 0.9.5
-------------

New features

. Users can define their own compiler directives. A directive can, for
  instance, change a set of plans to add a command in the end of all
  plans. See the new example "directives" for more information.

. Asynchronous ask in communication. When the internal action .send with
  an ask performative does not have the fourth argument, it does not suspend
  the intention. The answer is added to the sender's belief base.

Changes in AgentSpeak semantics
. "-b" in a plan removes "b[source(self)]" from the Belief Base and 
  not b with its all annotations. However, the source(self) annotation
  is added only in case b has no annots. For -b[a], the "self" source is
  not added and only annotation "a" is removed. 

Changes in internal actions
. Many internal actions were renamed to follow a Prolog pattern. E.g.,
  addPlan -> add_plan, createAgent -> create_agent.
. .drop_desire does not produce events anymore, it just removes the
  event from the circumstance.
. uses of .dropGoal(g,true) should be replaced by .succeed_goal(g).
. uses of .dropGoal(g,false) should be replaced by .fail_goal(g).
. new internal action .nth to select some term of a list.
  
Documentation
. all internal actions were documented using javadoc (see doc/api).

Bugs fixed in 0.9.5b
. The date in the application build.xml use latin characters.
. The variable name in the KQML plans may conflict with users' 
  variables.
. .sort changes the first parameter.
. the include directive can not be used before initial beliefs.

-------------
version 0.9.4
-------------

New features
. The user can define class paths for Jason projects, see the Sniffer
  project file (Sniffer.mas2j) for an example.

Examples:
. Add support form message sniffing in centralised infrastructure
  and improve the Sniffer example to use it (and also store all 
  messages in a data base)
. Improve the wandering capabilities in the Gold-Miners example.

Changes in the API
. The TermImpl was renamed to Structure
. The method that executes actions in the environment is not
	executeAction(String agName, Term act) 
  anymore, but was changed to
        executeAction(String agName, Structure act)
  So you should change your environment method parameters to 
  work with this version.

Bugs fixed:
. unification of variable in annotations


-------------
version 0.9.3
-------------

New features
. an event +!idle is generated when the agent has nothing to do
  (no other event, no intention, no message, ....)

. Mind inspector can show the agent state in LaTeX

. New commands: asl2html and asl2tex

. We add some useful classes to develop grid based environments. 
  There is a class to model (maintain the data) the scenario and
  another class to draw it in the screen. The examples CleaningRobots,
  DomesticRobot, and Gold-Miners use these classes. More information
  is available in these examples and in the API of package 
  import jason.environment.grid

. goal patterns as proposed in DALT 2006 paper:
  . Backtracking Declarative Goal
  . Blind Commitment Goal
  . Open-Minded Commitment
  . Maintenance Goal
  . Relativised Commitment Goal
  . and others


New examples
. Sniffer: shows how to get all messages sent by the agents.
. ContractNetProtocol: shows how the CNP may be implemented with Jason

New internal action:
. dropGoal(<goal>,[true|false]): the implementation of the
  .dropGoal as specified in DALT 2006 paper. All intentions
  with goal <goal> will be popped until the <goal> intended means (im).
  If the second parameter is true, the IM is considered successfully
  finished. Otherwise, the IM fails.

. member(<element>, <list>), verify whether <element> belong to the 
  <list>. this internal action backtracks when there are more than 
  one answer, as in 
       .member(X, [4,1,6])
  which has 3 results. 

. planLabel(<plan>, <label>), gets the string of a plan based on its
  label (useful for tellHow). E.g.:
    @test +!g : true <- act.
    ....
      <- .planLabel(P, test); 
         .send(ag,tellHow,P).

. structure(X): verify whether X is a structure (see API doc)

. atom(X): verify whether X is an atom (see API doc)


Changes in the communication
. performative ask is changed to askOne
. the event for messages is now +!kqmlReceived (and not +!received)
. send ask can have an 5th parameter: timeout. 
  E.g. .send(ag,askOne,vl(X),Answer,3000)
  will wait the answer for 3 seconds. If ag will not respond,
  Answer will unify with "timeout".
         

Changes in the API

. The interface of internal actions changed. The execute method returns 
  an Object, and not a boolean anymore, and the class may extends 
  DefaultInternalAction (see the API for more information). 
  For example:

    public class myIA extends DefaultInternalAction {
       public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
	     ....
         return true;
    }  }
      
  
-------------
version 0.9.2
-------------

New internal action:
. count(<bel>,<var>): count the number of beliefs that match
  <bel>.

New examples:
. SimpleCommunication: briefly shows how to send and receive
  messages.
. DomesticRobot: it is an improved version of the previous House robot.

Bugs fixes:
. performative ask does not work properly. 


-------------
version 0.9.1
-------------

New internal actions:
. random(X): unifies X with a random value from 0 to 1.
. date(YY,MM,DD): gets the current date
. time(HH,MM,SS): gets the current time
. var(X), string(X), number(X), ground(X), list(X): 
  verify whether X is a var, string, number, ground, or list.

Bugs fixed:
. Jason 0.9.1 correctly stops the running project (in windows). 
  In Jason 0.9 some java.exe processes do not finish properly. 

-----------
version 0.9
-----------

This version requires java 1.5.

New features:
. Belief Base (BB) can be customised. There are two available
  customisations: one that stores the beliefs in a text file and 
  another that stores them in a relational DB. This latter
  customisation can also be used the access any other
  relational DB (via  JDBC). The AgentSpeak code remains the
  same regardless of the BB customisation.
  See the "persistentBelBase" example for more information.

Changes in the AgentSpeak syntax
. there can be initial goals in the source code, e.g.:
    bel(a).
    !initgoal.
    +!initgoal : .... <- ....

. belief base can have simple (prolog-like) inferences rules, e.g.:
    a(10).
    a(20).
    b(20).
    c(X) :- a(X) & b(X).

. or (represented by "|") is allowed in plans' context, e.g.:
    +e : a | b <- ....
    +e : a & not(b | c) <- ....
  Disjunction is also possible in the inference rules in the belief base.

. 'true' context or plans can be omitted. e.g.:
        +e : c <- true.
        +e : true <- !g.
        +!e : true <- true.
  can be written as
        +e : c.
	+e <- !g.
	+!e.

. new operator "-+", which can appear in a plan body, adds a belief
  after removing (the first) existing occurrence of that belief in the
  belief base, e.g.:
    -+a(X+1)
  removes a(_) from and adds a(X+1) to the belief base.

. new plan annotation: "all_unifs". When a plan's label has this
  annotation the list of applicable plans will include all possible
  unifications (the same plan can lead to more than one Option), e.g.:
    a(10).
    a(20).
    @l[all_unifs] +!g : a(X) <- print(X).
  "+!g" has two options, one where X=10 and another where X=20.

. the arithmetic operator % was renamed to "mod"


Changes in .mas2j file
. the environment class can receive parameters from the .mas2j file. 
  e.g. in a mas2j file:
      ...
      environment: myenv(1,"a b c",vl)
      ...
  the environment implementation will receive these parameters
  in the init method:
      public void init(String[] args) { ... } 


Changes in the API
. the BRF method, in the "Agent" class, was renamed to BUF (Belief Update
  Function). A new BRF method was added for belief *revision* rather
  than update.
  While BUF is called to update the BB when percepts are obtained, BRF
  is called for `+', `-', and `-+' operators (those used in AS plans).
  Note that certain custmosations of BRF may require that BUF is
  customised to use BRF for the actual changes in the BB.

Other changes
. the "src/templates" folders contains all sources used by the JasonIDE
  to create new files (e.g., when users request a new agent or a new
  project to be created).

. new internal action ".length(<string>|<list>, <size>)": gets the size
  of a list or string
. new internal action ".abolish(<literal>)": remove all ocurrences of a
  literal from BB

. Performatives "askOne" and "askIf" are new "ask".
. Events generated from received KQML messages are not "+received(....)", but
  "+!received(...)".
  

-----------
version 0.8
-----------

New features
   . Jason is now a jEdit (www.jedit.org) plugin.
   . Jason was prepared for new infrastructures (Jade, MadKit, ...)
     To create a new infrastructure, you shoud add an infrastrucure Factory
     in .jason/user.properties file and implement some classes. 
     See jason.infra.centralised and jason.infra.saci packages as examples.
   . AS syntax was changed to support include directive,
     e.g. in an AS file:
    	.... plans ....
	    { include("anotherfile.asl") }
	    .... more plans ....
   . new internal action wait, e.g. in an AS file:
	  +a : true <- .wait(1000). // waits 1 second
	  +a : true <- .wait("+!x"). // waits an event
   . new internal action sort, e.g. in an AS file:
      .... .sort([b,c,g,casa,f(10),[3,4],[3,1],f(4)],L); ...
     L is [b,c,casa,f(4),f(10),g,[3,1],[3,4]]
   
   
Changes in .mas2j file
   . The user can inform its own parameters in the agent declaration, e.g.:
     .... agents: ag1 [verbose=2,file="a.xml",value=45];
     These extra parameters are stored in the Settings class and can be
     consulted in the programmer classes by getUserParameter method, 
     for example, 
       ts.getSettings().getUserParameter("file");

Changes in ASL syntax
   . the unnamed variable ("_") is added
   . annotations are an AS list, so it is possible constructions like
	     p(t)[a,b,c] = p(t)[b|R]     (R is [a,c])
   . variables can have annotations, e.g.
         X[a,b,c] = p[a,b,c,d] (unifies and X is p)
         p[a,b] = X[a,b,c]     (unifies and X is p)
         X[a,b] = p[a]         (do not unify)
         p[a,b] = X[a]         (do not unify)
     e.g in a plan
         +te : X[source(ag1)] <- do(X).
   . plans' trigger event can be a variable, e.g.
    	+!X[source(S)] : not friend(S) <- .send(S, tell, no).
   . new operator =.. used to (de)construct literals, syntax:
       <literal> =.. <list>
     where <list> is [<functor>, <list of terms>, <list of annots>] 
     e.g.
       p(t1,t2)[a1,a2] =.. L      (L is [p,[t1,t2],[a1,a2]])
       X =.. [p,[t1,t2],[a1,a2]]  (X is p(t1,t2)[a1,a2])
   . new operator "!!": sub-goal with new focus
   . new operator "div": integer division
   
Changes in the agent architecture customisation
   . In this version, the user extends AgArch class instead of Centralised
     or Saci architectures. Thus, the same architecture
     customisation can be used in both infrastructures.

Other changes
   . The Java logging API is used to output the execution. 
     The default log configuration is in the
     src/logging.properties file. The user can copy this file to its 
     project directory to customise the output format.
   . The internalAction removePlan use plan's label as argument instead of
     plan's strings.
   . Ant is used to run the MAS, for each project a build.xml file is
     created. The build template file is located in src/xml directory.
     If the project has a file called c-build.xml, the build.xml file
     is not created and this script is used instead.

-----------
version 0.7
-----------

New features
. atomic execution of intention. When an intention is created from
  a plan with a label that has an 'atomic' annotation 
     @label[atomic] +.... : .... <- ....
  this intention has highest priority, no other intention will be selected
  until this one was finished. 
. breakpoint annotation in plans' label
. editor syntax highlight for AS/MAS2J
. online parsing on editing
. number of cycles until perception (see manual)
. new AS grammar that supports expressions, e.g.
  +b : true : X = 4; Y = X + 3 * X / 2; ...
. jar files in the application lib directory are automatically added in the
  classpath

Changes in the Environment programming
. Each agent has its own perception list in version 0.7. 
  In the application Environment class, the user can change these lists by
  calling
  . addPercept(P): add perception P in the perception of all agents;
  . addPercept(A,P): add perception P only in the agent A's perception.
  . removePercept(P): ...
  . removePercept(A,P): ...
  The method getPercepts(A) returns the perceptions for agent A.
  See Environment javadoc API for more information.

. Perception is now a list of Literals, thus there is not anymore a
  positive and a negative list of Predicates.

  a code like 
    getPercepts().add(Term.parse("p(a)"));
  should now be written as
    addPercept(Literal.parseLiteral("p(a)"));

  and a code like
    getNegativePercepts().add(Term.parse("p(a)")); 
  should now be written as
    addPercept(Literal.parseLiteral("~p(a)"));

Changes in Internal Actions
   . Internal actions args are now terms and not Strings
   . Internal actions implements InternalAction interface
   . Each agent has its own IA objects -- IA has a state for its agent
        
Other changes
   . auto-save before running
   . brf() was moved to Agent class (and architecture perceive returns a List of perceptions)
   . The log4j is used to output the execution. The default log configuration is in the
     src/log4j.configuration file. The user can copy this file to its project directory
     to customise the output format.
     See http://logging.apache.org/log4j/docs/ for more information.
   . environment is optional in mas2j
   . initial beliefs generate events like + operator.
   

-----------
version 0.6
-----------
 
New features
. Two execution modes: async and sync (see doc/faq.html)
. Debugging execution mode with "mind inspector" tool
   (works both for centralised and distributed agents)

Agent Communication
. new implementation: all received messages create an event that
   is handled by standard AS plans (see bin/resources/kqmlPlans.asl file)
. acceptTell/Trust functions are replaced by socAcc (see manual)

Changes to AS syntax
. variables can be used where literals are expected, and a few
   other changes (see manual)

Changes to .mas2j file syntax
. user can set a controller class (see grammar) and doc/faq
. Environment.notifyEvents() was renamed to informAgsEnvironmentChanged()
. default architecture is centralised, not Saci.

Changes in the API
. the classes was reorganised into new packages. 
  An User's environment class
  needs the following imports:
	import jason.*;
	import jason.asSyntax.*;
	import jason.environment.*;

Other changes
. the ulibs dir. is not used anymore. The user classes should be
   placed in his/her project directory (or in any directory in your CLASSPATH)
. source annotation in predicates now have the form "[source(self)]" instead of
   "[self]" (similarly for perception and other agents as sources).
. Saci is included in the distribuion
  
-----------
version 0.5
-----------

Changes at .mas2j file syntax
. the user can use java packages for his/her classes 
  (see examples/Simple)

Changes in agentSpeak syntax
. the plan context can use infix relational operators (<, <=, >, >=, ==, \==, = (unify))
  for example:
      +p(X,Y) : X >= Y 
                <- !doSomeThing().

. the plan label must be prefixed by "@", e.g.:
	@label +trigger : true <- action1; action2.

Changes in the API
. The jason packages was refactored. The user environment class imports 
  likely will need to be rewritten to:
   import jason.asSyntax.*;
   import jason.environment.*;

. Some methods' name has changed:
  . Term.parameter -> Term.getTerm(i)
  . Term.funcSymb -> Term.getFunctor()

A new internal action, .broadcast(<ilforce>,<content>), was added.


-----------
version 0.4
-----------

The implementation of the user-defined environment class has been
changed so as to allow users to specify customised perception for
each individual agent.

Users who used old-style environment code such as:

public class marsEnv implements Environment {
    <code1>
    EnvironmentPerception envP = null;
    public void setEnvironmentPerception(EnvironmentPerception ep) {
        envP = ep;
	<code2>
    }
    <code3>
}

should be changed to:

public class marsEnv extends Environment {
    <code1>    
    public marsEnv() {
        <code2>
    }
    <code3>
}

Briefly, the changes are as follows:

  1. The user's environment class does not "implements Environment"
     anymore, but "extends Environment". (See API documentation
     for more information on this new class.)

  2. The method setEnvironmentPerception, where the environment
     initialisation was done, is replaced by the user environment
     constructor.

  3. To change the environment perception list use:
     getPercepts().remove(g1); instead of
     envP.getPercepts().remove(g1);

  4. To send specific perceptions for an individual agent, override
     the method getPercepts(agName); for example:

     public class marsEnv extends Environment {
       ...
       public List getPercepts(String agName) {
         if (agName.equals(...)) {
           List customPercepts = new LinkedList(super.getPercepts(agName));
           customPercepts.add(...);
           customPercepts.remove(...);
           return customPercepts;
         } else {
           return super.getPerceps(agName);
         }
       }
       ...
     }


The option "event=retrieve" was added. It makes the selectOption function be called even if there is not relevant plans.


-----------
version 0.3
-----------

Jason now has an IDE! This version of Jason also runs on MS
Windows, if you must.


-----------
version 0.2
-----------

First public release.

Agent and AgentArchitecture classes are only required if the user
needs to provide any customisation. The same environment code now
works for Saci and Centralised.


-----------
version 0.1
-----------

The very first release of Jason!
